{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TensorFlow version: 2.0.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import datetime, os\n",
    "#hide tf logs\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # or any {'0', '1', '2'},\n",
    "#0 (default) shows all, 1 to filter out INFO logs, 2 to additionally filter out WARNING logs, and 3 to additionally filter out ERROR logs\n",
    "import scipy.optimize\n",
    "import scipy.io\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker\n",
    "import time\n",
    "from pyDOE import lhs         #Latin Hypercube Sampling\n",
    "import pandas as pd\n",
    "import seaborn as sns \n",
    "import codecs, json\n",
    "\n",
    "# generates same random numbers each time\n",
    "np.random.seed(1234)\n",
    "tf.random.set_seed(1234)\n",
    "\n",
    "print(\"TensorFlow version: {}\".format(tf.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *Data Prep*\n",
    "\n",
    "Training and Testing data is prepared from the solution file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_1 = np.linspace(-1,1,256)  # 256 points between -1 and 1 [256x1]\n",
    "x_2 = np.linspace(1,-1,256)  # 256 points between 1 and -1 [256x1]\n",
    "\n",
    "X, Y = np.meshgrid(x_1,x_2) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test Data\n",
    "\n",
    "We prepare the test data to compare against the solution produced by the PINN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_u_test = np.hstack((X.flatten(order='F')[:,None], Y.flatten(order='F')[:,None]))\n",
    "\n",
    "# Domain bounds\n",
    "lb = np.array([-1, -1]) #lower bound\n",
    "ub = np.array([1, 1])  #upper bound\n",
    "\n",
    "a_1 = 1 \n",
    "a_2 = 1\n",
    "\n",
    "usol = np.sin(a_1 * np.pi * X) * np.sin(a_2 * np.pi * Y) #solution chosen for convinience  \n",
    "\n",
    "u = usol.flatten('F')[:,None] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trainingdata(N_u,N_f):\n",
    "    \n",
    "    leftedge_x = np.hstack((X[:,0][:,None], Y[:,0][:,None]))\n",
    "    leftedge_u = usol[:,0][:,None]\n",
    "    \n",
    "    rightedge_x = np.hstack((X[:,-1][:,None], Y[:,-1][:,None]))\n",
    "    rightedge_u = usol[:,-1][:,None]\n",
    "    \n",
    "    topedge_x = np.hstack((X[0,:][:,None], Y[0,:][:,None]))\n",
    "    topedge_u = usol[0,:][:,None]\n",
    "    \n",
    "    bottomedge_x = np.hstack((X[-1,:][:,None], Y[-1,:][:,None]))\n",
    "    bottomedge_u = usol[-1,:][:,None]\n",
    "    \n",
    "    all_X_u_train = np.vstack([leftedge_x, rightedge_x, bottomedge_x, topedge_x])\n",
    "    all_u_train = np.vstack([leftedge_u, rightedge_u, bottomedge_u, topedge_u])  \n",
    "     \n",
    "    #choose random N_u points for training\n",
    "    idx = np.random.choice(all_X_u_train.shape[0], N_u, replace=False) \n",
    "    \n",
    "    X_u_train = all_X_u_train[idx[0:N_u], :] #choose indices from  set 'idx' (x,t)\n",
    "    u_train = all_u_train[idx[0:N_u],:]      #choose corresponding u\n",
    "    \n",
    "    '''Collocation Points'''\n",
    "\n",
    "    # Latin Hypercube sampling for collocation points \n",
    "    # N_f sets of tuples(x,t)\n",
    "    X_f = lb + (ub-lb)*lhs(2,N_f) \n",
    "    X_f_train = np.vstack((X_f, X_u_train)) # append training points to collocation points \n",
    "    \n",
    "    return X_f_train, X_u_train, u_train \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PINN \n",
    "\n",
    "$W \\in \\mathcal{R}^{n_{l-1}\\times{n_l}}$ \n",
    "\n",
    "Creating sequential layers using the $\\textit{class}$ tf.Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sequentialmodel(tf.Module): \n",
    "    def __init__(self, layers, name=None):\n",
    "\n",
    "        self.W = []  #Weights and biases\n",
    "        self.parameters = 0 #total number of parameters\n",
    "\n",
    "        for i in range(len(layers)-1):\n",
    "\n",
    "            input_dim = layers[i]\n",
    "            output_dim = layers[i+1]\n",
    "\n",
    "            #Xavier standard deviation \n",
    "            std_dv = np.sqrt((2.0/(input_dim + output_dim)))\n",
    "\n",
    "            #weights = normal distribution * Xavier standard deviation + 0\n",
    "            w = tf.random.normal([input_dim, output_dim], dtype = 'float64') * std_dv\n",
    "            \n",
    "#             w = tf.cast(tf.ones([input_dim, output_dim]), dtype = 'float64')\n",
    "\n",
    "            w = tf.Variable(w, trainable=True, name = 'w' + str(i+1))\n",
    "\n",
    "            b = tf.Variable(tf.cast(tf.zeros([output_dim]), dtype = 'float64'), trainable = True, name = 'b' + str(i+1))\n",
    "\n",
    "            self.W.append(w)\n",
    "            self.W.append(b)\n",
    "\n",
    "            self.parameters +=  input_dim * output_dim + output_dim\n",
    "            \n",
    "        self.X = np.zeros(self.parameters) #store iterates\n",
    "        self.G = np.zeros(self.parameters) #store gradients\n",
    "        self.store = np.zeros((max_iter,2)) #store computed values for plotting\n",
    "        self.iter_counter = 0 # iteration counter for optimizer\n",
    "    \n",
    "    def evaluate(self,x):\n",
    "        \n",
    "        #preprocessing input \n",
    "        x = (x - lb)/(ub - lb) #feature scaling\n",
    "        \n",
    "        a = x\n",
    "        \n",
    "        for i in range(len(layers)-2):\n",
    "            \n",
    "            z = tf.add(tf.matmul(a, self.W[2*i]), self.W[2*i+1])\n",
    "            a = tf.nn.tanh(z)\n",
    "            \n",
    "        a = tf.add(tf.matmul(a, self.W[-2]), self.W[-1]) # For regression, no activation to last layer\n",
    "        \n",
    "        return a\n",
    "    \n",
    "    def get_weights(self):\n",
    "\n",
    "        parameters_1d = []  # [.... W_i,b_i.....  ] 1d array\n",
    "        \n",
    "        for i in range (len(layers)-1):\n",
    "            \n",
    "            w_1d = tf.reshape(self.W[2*i],[-1])   #flatten weights \n",
    "            b_1d = tf.reshape(self.W[2*i+1],[-1]) #flatten biases\n",
    "            \n",
    "            parameters_1d = tf.concat([parameters_1d, w_1d], 0) #concat weights \n",
    "            parameters_1d = tf.concat([parameters_1d, b_1d], 0) #concat biases\n",
    "        \n",
    "        return parameters_1d\n",
    "        \n",
    "    def set_weights(self,parameters):\n",
    "                \n",
    "        for i in range (len(layers)-1):\n",
    "\n",
    "            shape_w = tf.shape(self.W[2*i]).numpy() # shape of the weight tensor\n",
    "            size_w = tf.size(self.W[2*i]).numpy() #size of the weight tensor \n",
    "            \n",
    "            shape_b = tf.shape(self.W[2*i+1]).numpy() # shape of the bias tensor\n",
    "            size_b = tf.size(self.W[2*i+1]).numpy() #size of the bias tensor \n",
    "                        \n",
    "            pick_w = parameters[0:size_w] #pick the weights \n",
    "            self.W[2*i].assign(tf.reshape(pick_w,shape_w)) # assign  \n",
    "            parameters = np.delete(parameters,np.arange(size_w),0) #delete \n",
    "            \n",
    "            pick_b = parameters[0:size_b] #pick the biases \n",
    "            self.W[2*i+1].assign(tf.reshape(pick_b,shape_b)) # assign \n",
    "            parameters = np.delete(parameters,np.arange(size_b),0) #delete \n",
    "\n",
    "            \n",
    "    def loss_BC(self,x,y):\n",
    "\n",
    "        loss_u = tf.reduce_mean(tf.square(y-self.evaluate(x)))\n",
    "        return loss_u\n",
    "\n",
    "    def loss_PDE(self, x_to_train_f):\n",
    "    \n",
    "        g = tf.Variable(x_to_train_f, dtype = 'float64', trainable = False)\n",
    "\n",
    "        k = 1    \n",
    "\n",
    "        x_1_f = g[:,0:1]\n",
    "        x_2_f = g[:,1:2]\n",
    "\n",
    "        with tf.GradientTape(persistent=True) as tape:\n",
    "\n",
    "            tape.watch(x_1_f)\n",
    "            tape.watch(x_2_f)\n",
    "\n",
    "            g = tf.stack([x_1_f[:,0], x_2_f[:,0]], axis=1)\n",
    "\n",
    "            u = self.evaluate(g)\n",
    "            u_x_1 = tape.gradient(u,x_1_f)\n",
    "            u_x_2 = tape.gradient(u,x_2_f)\n",
    "\n",
    "        u_xx_1 = tape.gradient(u_x_1,x_1_f)\n",
    "        u_xx_2 = tape.gradient(u_x_2,x_2_f)\n",
    "\n",
    "        del tape\n",
    "\n",
    "        q = -( (a_1*np.pi)**2 + (a_2*np.pi)**2 - k**2 ) * np.sin(a_1*np.pi*x_1_f) * np.sin(a_2*np.pi*x_2_f)\n",
    "\n",
    "        f = u_xx_1 + u_xx_2 + k**2 * u - q #residual\n",
    "\n",
    "        loss_f = tf.reduce_mean(tf.square(f))\n",
    "\n",
    "        return loss_f, f\n",
    "    \n",
    "    def loss(self,x,y,g):\n",
    "\n",
    "        loss_u = self.loss_BC(x,y)\n",
    "        loss_f, f = self.loss_PDE(g)\n",
    "\n",
    "        loss = loss_u + loss_f\n",
    "\n",
    "        return loss, loss_u, loss_f \n",
    "    \n",
    "    def optimizerfunc(self,parameters):\n",
    "        \n",
    "        self.set_weights(parameters)\n",
    "       \n",
    "        with tf.GradientTape() as tape:\n",
    "            tape.watch(self.trainable_variables)\n",
    "            \n",
    "            loss_val, loss_u, loss_f = self.loss(X_u_train, u_train, X_f_train)\n",
    "            \n",
    "        grads = tape.gradient(loss_val,self.trainable_variables)\n",
    "                \n",
    "        del tape\n",
    "        \n",
    "        grads_1d = [ ] #store 1d grads \n",
    "        \n",
    "        for i in range (len(layers)-1):\n",
    "\n",
    "            grads_w_1d = tf.reshape(grads[2*i],[-1]) #flatten weights \n",
    "            grads_b_1d = tf.reshape(grads[2*i+1],[-1]) #flatten biases\n",
    "\n",
    "            grads_1d = tf.concat([grads_1d, grads_w_1d], 0) #concat grad_weights \n",
    "            grads_1d = tf.concat([grads_1d, grads_b_1d], 0) #concat grad_biases\n",
    "        \n",
    "        return loss_val.numpy(), grads_1d.numpy()\n",
    "    \n",
    "    def optimizer_callback(self,parameters):\n",
    "                \n",
    "        loss_value, loss_u, loss_f = self.loss(X_u_train, u_train, X_f_train)\n",
    "        \n",
    "        u_pred = self.evaluate(X_u_test)\n",
    "        error_vec = np.linalg.norm((u-u_pred),2)/np.linalg.norm(u,2)\n",
    "        \n",
    "        tf.print(loss_value, loss_u, loss_f, error_vec)\n",
    "        \n",
    "        self.LbfgsInvHessProduct(parameters)\n",
    "        \n",
    "    def LbfgsInvHessProduct(self,parameters):\n",
    "\n",
    "        self.iter_counter += 1  #update iteration counter \n",
    "\n",
    "        x_k = parameters  \n",
    "\n",
    "        self.X = np.vstack((x_k.T,self.X)) #stack latest value on top row\n",
    "\n",
    "        _,g_k = self.optimizerfunc(parameters) #obtain grads and loss value\n",
    "\n",
    "        self.G = np.vstack((g_k.T,self.G)) #stack latest grads on top row\n",
    "\n",
    "        n_corrs = min(self.iter_counter, maxcor) #for iterations < maxcor, we will take all available updates\n",
    "        \n",
    "        sk = self.X = self.X[:n_corrs] #select top 'n_corrs' x values, with latest value on top by construction\n",
    "        yk = self.G = self.G[:n_corrs] #select top 'n_corrs' gradient values, with latest value on top by construction \n",
    "\n",
    "        #linear operator B_k_inv    \n",
    "        hess_inv = scipy.optimize.LbfgsInvHessProduct(sk,yk) #instantiate class\n",
    "\n",
    "        p_k = - hess_inv.matvec(g_k) #p_k = -B_k_inv * g_k\n",
    "\n",
    "        gkpk = np.dot(p_k,g_k) #term 1 in report\n",
    "\n",
    "        norm_p_k_sq = (np.linalg.norm(p_k,ord=2))**2 # norm squared\n",
    "               \n",
    "        #store the values\n",
    "        self.store[self.iter_counter-1] = [gkpk,norm_p_k_sq]\n",
    "\n",
    "        def ls_function(x):\n",
    "            val, _ = self.optimizerfunc(x)\n",
    "            return val\n",
    "\n",
    "        def ls_gradient(x):\n",
    "            _, grad = self.optimizerfunc(x)\n",
    "            return grad\n",
    "\n",
    "        alpha, _, _, fnewval, _, _ = scipy.optimize.line_search(ls_function, ls_gradient, x_k, p_k, gfk = g_k, maxiter = 50, c1=1e-4, c2=0.9)\n",
    "        \n",
    "        \n",
    "        \"\"\"\n",
    "        Class\n",
    "        -------------\n",
    "\n",
    "        class scipy.optimize.LbfgsInvHessProduct(*args, **kwargs)\n",
    "\n",
    "        sk = array_like, shape=(n_corr, n)\n",
    "        Array of n_corr most recent updates to the solution vector.\n",
    "\n",
    "        yk = array_like, shape=(n_corr, n)\n",
    "        Array of n_corr most recent updates to the gradient.\n",
    "\n",
    "        Methods\n",
    "        -------------\n",
    "\n",
    "        __call__(self, x)  Call self as a function.\n",
    "\n",
    "        adjoint(self)      Hermitian adjoint.\n",
    "\n",
    "        dot(self, x)       Matrix-matrix or matrix-vector multiplication.\n",
    "\n",
    "        matmat(self, X)    Matrix-matrix multiplication.\n",
    "\n",
    "        matvec(self, x)    Matrix-vector multiplication.\n",
    "\n",
    "        rmatmat(self, X)   Adjoint matrix-matrix multiplication.\n",
    "\n",
    "        rmatvec(self, x)   Adjoint matrix-vector multiplication.\n",
    "\n",
    "        todense(self)      Return a dense array representation of this operator.\n",
    "\n",
    "        transpose(self)    Transpose this linear operator.\n",
    "\n",
    "        \"\"\"\n",
    "        \n",
    "        \n",
    "    def adaptive_gradients(self):\n",
    "\n",
    "        with tf.GradientTape() as tape:\n",
    "            tape.watch(self.W)\n",
    "            loss_val = self.loss(X_u_train, u_train, X_f_train)\n",
    "\n",
    "        grads = tape.gradient(loss_val,self.W)\n",
    "\n",
    "        del tape\n",
    "\n",
    "        return loss_val, grads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Calling GradientTape.gradient on a persistent tape inside its context is significantly less efficient than calling it outside the context (it causes the gradient ops to be recorded on the tape, leading to increased CPU and memory usage). Only call GradientTape.gradient inside the context if you actually want to trace the gradient in order to compute higher order derivatives.\n",
      "WARNING:tensorflow:Calling GradientTape.gradient on a persistent tape inside its context is significantly less efficient than calling it outside the context (it causes the gradient ops to be recorded on the tape, leading to increased CPU and memory usage). Only call GradientTape.gradient inside the context if you actually want to trace the gradient in order to compute higher order derivatives.\n",
      "(84.315437277715318, 0.022425928002549944, 84.293011349712771)\n",
      "(84.29752162396494, 0.010057726508764709, 84.287463897456178)\n",
      "(84.287164110403083, 0.0031544327283670819, 84.284009677674717)\n",
      "(84.282587468298786, 0.0010036383212865551, 84.281583829977492)\n",
      "(84.280455873110114, 0.0013877846941964837, 84.279068088415912)\n",
      "(84.27857404689523, 0.0025552457746485378, 84.276018801120586)\n",
      "(84.275595595008653, 0.003417878032315691, 84.272177716976344)\n",
      "(84.271259329510841, 0.0036871231829053953, 84.267572206327941)\n",
      "(84.266108513904157, 0.0036383382782653032, 84.2624701756259)\n",
      "(84.260651607060922, 0.0035327725887852324, 84.257118834472138)\n",
      "84.25529625024744 0.00357955895476025 84.251716691292685\n",
      "Test Error: 1.01259\n"
     ]
    }
   ],
   "source": [
    "N_u = 400 #Total number of data points for 'u'\n",
    "N_f = 10000 #Total number of collocation points \n",
    "\n",
    "# Training data\n",
    "X_f_train, X_u_train, u_train = trainingdata(N_u,N_f)\n",
    "\n",
    "layers = np.array([2, 50, 50, 50, 1]) #3 hidden layers\n",
    "\n",
    "maxcor = 200 \n",
    "max_iter = 5000\n",
    "\n",
    "PINN = Sequentialmodel(layers)\n",
    "\n",
    "optimizer = tf.keras.optimizers.Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07)\n",
    "\n",
    "num_epochs = 10\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    \n",
    "        loss_value, grads = PINN.adaptive_gradients()\n",
    "\n",
    "        tf.print(loss_value)\n",
    "        \n",
    "        optimizer.apply_gradients(zip(grads, PINN.W)) #gradient descent weights \n",
    "        \n",
    "        \n",
    "loss_value, loss_u, loss_f = PINN.loss(X_u_train, u_train, X_f_train)\n",
    "\n",
    "tf.print(loss_value, loss_u, loss_f)\n",
    "\n",
    "''' Model Accuracy ''' \n",
    "u_pred = PINN.evaluate(X_u_test)\n",
    "\n",
    "error_vec = np.linalg.norm((u-u_pred),2)/np.linalg.norm(u,2)        # Relative L2 Norm of the error (Vector)\n",
    "print('Test Error: %.5f'  % (error_vec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *Loss Function*\n",
    "\n",
    "The loss function consists of two parts:\n",
    "1. **loss_BC**: MSE error of boundary losses\n",
    "2. **loss_PDE**: MSE error of collocation points satisfying the PDE\n",
    "\n",
    "**loss** = loss_BC + loss_PDE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N_u = 400 #Total number of data points for 'u'\n",
    "N_f = 10000 #Total number of collocation points \n",
    "\n",
    "# Training data\n",
    "X_f_train, X_u_train, u_train = trainingdata(N_u,N_f)\n",
    "\n",
    "layers = np.array([2, 50, 50, 50, 1]) #3 hidden layers\n",
    "\n",
    "maxcor = 200 \n",
    "max_iter = 5000\n",
    "\n",
    "PINN = Sequentialmodel(layers)\n",
    "\n",
    "# #load saved weights \n",
    "# new_checkpoint = tf.train.Checkpoint(model = PINN)   # get checkpoint of new model\n",
    "# chkp_path = \"Non_Stiff_problem/my_checkpoint\"                # define stored path\n",
    "# new_checkpoint.restore(chkp_path)                    # overwrite new model variables \n",
    "\n",
    "init_params = PINN.get_weights().numpy()\n",
    "\n",
    "start_time = time.time() \n",
    "\n",
    "# train the model with Scipy L-BFGS optimizer\n",
    "results = scipy.optimize.minimize(fun = PINN.optimizerfunc, \n",
    "                                  x0 = init_params, \n",
    "                                  args=(), \n",
    "                                  method='L-BFGS-B', \n",
    "                                  jac= True,        # If jac is True, fun is assumed to return the gradient along with the objective function\n",
    "                                  callback = None, \n",
    "                                  options = {'disp': None,\n",
    "                                            'maxcor': maxcor, \n",
    "                                            'ftol': 1 * np.finfo(float).eps,  #The iteration stops when (f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} <= ftol\n",
    "                                            'gtol': 5e-10, \n",
    "                                            'maxfun':  50000, \n",
    "                                            'maxiter': 1,\n",
    "                                            'iprint': -1,   #print update every 50 iterations\n",
    "                                            'maxls': 50})\n",
    "\n",
    "elapsed = time.time() - start_time                \n",
    "print('Training time: %.2f' % (elapsed))\n",
    "\n",
    "print(results)\n",
    "\n",
    "# np.savetxt('values_stiff.txt', PINN.store)\n",
    "\n",
    "PINN.set_weights(results.x)\n",
    "\n",
    "''' Model Accuracy ''' \n",
    "u_pred = PINN.evaluate(X_u_test)\n",
    "\n",
    "error_vec = np.linalg.norm((u-u_pred),2)/np.linalg.norm(u,2)        # Relative L2 Norm of the error (Vector)\n",
    "print('Test Error: %.5f'  % (error_vec))\n",
    "\n",
    "u_pred = np.reshape(u_pred,(256,256),order='F') \n",
    "\n",
    "# Plotting\n",
    "\n",
    "#Ground truth\n",
    "fig_1 = plt.figure(1, figsize=(18, 5))\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.pcolor(x_1, x_2, usol, cmap='jet')\n",
    "plt.colorbar()\n",
    "plt.xlabel(r'$x_1$', fontsize=18)\n",
    "plt.ylabel(r'$x_2$', fontsize=18)\n",
    "plt.title('Ground Truth $u(x_1,x_2)$', fontsize=15)\n",
    "\n",
    "# Prediction\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.pcolor(x_1, x_2, u_pred, cmap='jet')\n",
    "plt.colorbar()\n",
    "plt.xlabel(r'$x_1$', fontsize=18)\n",
    "plt.ylabel(r'$x_2$', fontsize=18)\n",
    "plt.title('Predicted $\\hat u(x_1,x_2)$', fontsize=15)\n",
    "\n",
    "# Error\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.pcolor(x_1, x_2, np.abs(usol - u_pred), cmap='jet')\n",
    "plt.colorbar()\n",
    "plt.xlabel(r'$x_1$', fontsize=18)\n",
    "plt.ylabel(r'$x_2$', fontsize=18)\n",
    "plt.title(r'Absolute error $|u(x_1,x_2)- \\hat u(x_1,x_2)|$', fontsize=15)\n",
    "plt.tight_layout()\n",
    "\n",
    "fig.savefig('Helmholtz_non_stiff.png', dpi = 500, bbox_inches='tight')\n",
    "\n",
    "# #Residual plot\n",
    "# loss_f, f_plot = PINN.loss_PDE(X_u_test)\n",
    "# plt.scatter(X_u_test[:,0:1], X_u_test[:,1:2], c=f_plot, cmap = 'jet')\n",
    "# plt.axis('scaled')\n",
    "# plt.colorbar()\n",
    "# plt.savefig('Stiff_Helmholtz_residual.png', dpi = 500)\n",
    "\n",
    "# #plot gkpk\n",
    "# plt.semilogy(PINN.store[:,0])\n",
    "# plt.yscale('symlog')\n",
    "# plt.savefig('gkpk_stiff.png', dpi = 500)\n",
    "\n",
    "# #plot norm_p_k_sq\n",
    "# plt.semilogy(PINN.store[:,1])\n",
    "# plt.yscale('symlog')\n",
    "# plt.savefig('norm_p_k_sq_stiff.png', dpi = 500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot of collocation points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N_u = 400 #Total number of data points for 'u'\n",
    "N_f = 10000 #Total number of collocation points \n",
    "\n",
    "# Training data\n",
    "X_f_train, X_u_train, u_train = trainingdata(N_u,N_f)\n",
    "\n",
    "fig,ax = plt.subplots()\n",
    "\n",
    "plt.plot(X_u_train[:,0],X_u_train[:,1], '*', color = 'red', markersize = 5, label = 'Boundary collocation points= 400')\n",
    "plt.plot(X_f_train[:,0],X_f_train[:,1], 'o', markersize = 0.5, label = 'PDE collocation points = 10,000')\n",
    "\n",
    "plt.xlabel(r'$x_1$')\n",
    "plt.ylabel(r'$x_2$')\n",
    "plt.title('Collocation points')\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "plt.axis('scaled')\n",
    "plt.show()\n",
    "\n",
    "# fig.savefig('collocation_points_Helmholtz.png', dpi = 500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transfer Learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Non_stiff/my_checkpoint'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chkp_path = \"Stiff_problem/my_checkpoint\"  #path to store file\n",
    "checkpoint = tf.train.Checkpoint(model = PINN) #tf.Module can be saved as checkpoint\n",
    "checkpoint.write(chkp_path)                    #write to path "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('_CHECKPOINTABLE_OBJECT_GRAPH', []),\n",
       " ('model/W/0/.ATTRIBUTES/VARIABLE_VALUE', [2, 50]),\n",
       " ('model/W/1/.ATTRIBUTES/VARIABLE_VALUE', [50]),\n",
       " ('model/W/2/.ATTRIBUTES/VARIABLE_VALUE', [50, 50]),\n",
       " ('model/W/3/.ATTRIBUTES/VARIABLE_VALUE', [50]),\n",
       " ('model/W/4/.ATTRIBUTES/VARIABLE_VALUE', [50, 50]),\n",
       " ('model/W/5/.ATTRIBUTES/VARIABLE_VALUE', [50]),\n",
       " ('model/W/6/.ATTRIBUTES/VARIABLE_VALUE', [50, 1]),\n",
       " ('model/W/7/.ATTRIBUTES/VARIABLE_VALUE', [1])]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.train.list_variables(chkp_path)             #look inside checkpoint and ensure everything is saved"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.GradientTape(persistent=True) as tape:\n",
    "    loss_value, loss_u, loss_f = PINN.loss(X_u_train, u_train, X_f_train)\n",
    "    grad_u = tape.gradient(loss_u, PINN.trainable_variables) \n",
    "    grad_f = tape.gradient(loss_f, PINN.trainable_variables)\n",
    "    del tape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing gradients to 2 separate JSON files \n",
    "\n",
    "L = len(layers)-1 #number of weights matrices\n",
    "\n",
    "for i in range (L*2):\n",
    "\n",
    "    temp = grad_f[i].numpy().tolist() # nested lists with same data, indices\n",
    "    json.dump(temp, codecs.open(\"Stiff_problem/Gradients/gradients_f\" + str(i) + \".json\", 'w', encoding='utf-8'), separators=(',', ':'), sort_keys=True, indent=0)\n",
    "    \n",
    "    temp = grad_u[i].numpy().tolist() # nested lists with same data, indices\n",
    "    json.dump(temp, codecs.open(\"Stiff_problem/Gradients/gradients_u\" + str(i) + \".json\", 'w', encoding='utf-8'), separators=(',', ':'), sort_keys=True, indent=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_1 = {} #residual non-stiff problem\n",
    "u_1 = {} #boundary non-stiff problem\n",
    "\n",
    "f_2 = {} #residual stiff problem\n",
    "u_2 = {} #boundary stiff problem\n",
    "\n",
    "L = 4\n",
    "\n",
    "#Reading gradients from JSON files and storing in a dict \n",
    "#storing gradients of both weights and biases\n",
    "\n",
    "for i in range (L):\n",
    "    \n",
    "    #weights and biases\n",
    "#     obj_text_w = codecs.open(\"Non_Stiff_problem/Gradients/gradients_f\" + str(2*i) + \".json\", 'r', encoding='utf-8').read()\n",
    "#     obj_text_b = codecs.open(\"Non_Stiff_problem/Gradients/gradients_f\" + str(2*i+1) + \".json\", 'r', encoding='utf-8').read()\n",
    "#     f_1['f'+ str(i)] = np.concatenate((np.array(json.loads(obj_text_w)).flatten('F'), np.array(json.loads(obj_text_b)).flatten('F')))\n",
    "    \n",
    "#     obj_text_w = codecs.open(\"Non_Stiff_problem/Gradients/gradients_u\" + str(2*i) + \".json\", 'r', encoding='utf-8').read()\n",
    "#     obj_text_b = codecs.open(\"Non_Stiff_problem/Gradients/gradients_u\" + str(2*i+1) + \".json\", 'r', encoding='utf-8').read()\n",
    "#     u_1['u'+ str(i)] = np.concatenate((np.array(json.loads(obj_text_w)).flatten('F'), np.array(json.loads(obj_text_b)).flatten('F')))\n",
    "    \n",
    "    obj_text_w = codecs.open(\"Stiff_problem/Gradients/gradients_f\" + str(2*i) + \".json\", 'r', encoding='utf-8').read()\n",
    "    obj_text_b = codecs.open(\"Stiff_problem/Gradients/gradients_f\" + str(2*i+1) + \".json\", 'r', encoding='utf-8').read()\n",
    "    f_2['f'+ str(i)] = np.concatenate((np.array(json.loads(obj_text_w)).flatten('F'), np.array(json.loads(obj_text_b)).flatten('F')))\n",
    "    \n",
    "    obj_text_w = codecs.open(\"Stiff_problem/Gradients/gradients_u\" + str(2*i) + \".json\", 'r', encoding='utf-8').read()\n",
    "    obj_text_b = codecs.open(\"Stiff_problem/Gradients/gradients_u\" + str(2*i+1) + \".json\", 'r', encoding='utf-8').read()\n",
    "    u_2['u'+ str(i)] = np.concatenate((np.array(json.loads(obj_text_w)).flatten('F'), np.array(json.loads(obj_text_b)).flatten('F')))\n",
    "    \n",
    "    \n",
    "#     #only weights\n",
    "#     obj_text_w = codecs.open(\"Non_Stiff_problem/Gradients/gradients_f\" + str(2*i) + \".json\", 'r', encoding='utf-8').read()\n",
    "#     f_1['f'+ str(i)] = np.array(json.loads(obj_text_w)).flatten('F')\n",
    "    \n",
    "#     obj_text_w = codecs.open(\"Non_Stiff_problem/Gradients/gradients_u\" + str(2*i) + \".json\", 'r', encoding='utf-8').read()\n",
    "#     u_1['u'+ str(i)] = np.array(json.loads(obj_text_w)).flatten('F')\n",
    "    \n",
    "#     obj_text_w = codecs.open(\"Stiff_problem/Gradients/gradients_f\" + str(2*i) + \".json\", 'r', encoding='utf-8').read()\n",
    "#     f_2['f'+ str(i)] = np.array(json.loads(obj_text_w)).flatten('F')\n",
    "    \n",
    "#     obj_text_w = codecs.open(\"Stiff_problem/Gradients/gradients_u\" + str(2*i) + \".json\", 'r', encoding='utf-8').read()\n",
    "#     u_2['u'+ str(i)] = np.array(json.loads(obj_text_w)).flatten('F')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Plot the gradients\n",
    "#seaborn = 0.9.0\n",
    "\n",
    "cnt = 1\n",
    "fig = plt.figure(4, figsize=(13, 4))\n",
    "\n",
    "for i in range (L):\n",
    "    \n",
    "    ax = plt.subplot(1, 4, cnt)\n",
    "    ax.set_title('Layer {}'.format(i + 1))\n",
    "    ax.set_yscale('symlog')\n",
    "    \n",
    "    gradients_res = f_2['f'+ str(i)]\n",
    "    gradients_bcs = u_2['u'+ str(i)]\n",
    "      \n",
    "    sns.distplot(gradients_bcs, hist=False,\n",
    "                 kde_kws={\"shade\": False},\n",
    "                 norm_hist=False, label=r'$\\nabla_{\\theta} \\hat J_{BC}$')\n",
    "    \n",
    "    sns.distplot(gradients_res, hist=False,\n",
    "                 kde_kws={\"shade\": False},\n",
    "                 norm_hist=False, label=r'$\\nabla_{\\theta} \\hat J_{PDE}$')\n",
    "\n",
    "    ax.get_legend().remove()\n",
    "    ax.set_xlim([-1e-1, 1e-1])\n",
    "    ax.set_ylim([0,1e6])\n",
    "    cnt += 1\n",
    "    \n",
    "handles, labels = ax.get_legend_handles_labels()\n",
    "fig.legend(handles, labels, loc=\"upper left\", bbox_to_anchor=(0.35, -0.01),\n",
    "             borderaxespad=0, bbox_transform=fig.transFigure, ncol=2)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# fig.savefig('Gradient_histogram_stiff.png', dpi = 500, bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data = np.loadtxt(\"Stiff_problem/convergence_history.txt\", comments = \"#\", delimiter = \" \", unpack = False)\n",
    "\n",
    "# fig,ax = plt.subplots()\n",
    "# plt.semilogy(np.arange(1,5001),data[:,0], color = 'blue', label = '$\\hat J_{PINN} = \\hat J_{BC} + \\hat J_{PDE}$')\n",
    "# plt.semilogy(np.arange(1,5001),data[:,1], color = 'green', label = ' $\\hat J_{BC}$')\n",
    "# plt.semilogy(np.arange(1,5001),data[:,2], color = 'orange', label = '$\\hat J_{PDE}$')\n",
    "# plt.semilogy(np.arange(1,5001),data[:,3], color = 'red', label = '$\\epsilon_{PINN}$')\n",
    "\n",
    "# ax.set_yticks([1e4, 1e3, 1e2, 1e1, 1e0, 1e-1, 1e-2, 1e-3])\n",
    "\n",
    "# plt.legend()\n",
    "# ax.set_xlabel('iterations')\n",
    "# ax.set_ylabel('Loss/Error')\n",
    "# plt.grid()\n",
    "# plt.show()\n",
    "\n",
    "# # fig.savefig('Stiff_Helmholtz_convergence_history.eps', format = 'eps')\n",
    "# # fig.savefig('Stiff_Helmholtz_convergence_history.png', dpi = 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# B =  results.hess_inv.todense() #hessian estimate\n",
    "\n",
    "# B = tf.convert_to_tensor(B, dtype = tf.float32)\n",
    "\n",
    "# v = tf.linalg.eigvalsh(B)\n",
    "\n",
    "# np.savetxt(\"stiff_eig_maxcor_100.txt\", v)\n",
    "\n",
    "# plt.semilogy(v)\n",
    "# plt.savefig('stiff_eig_maxcor_100.png', dpi = 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEHCAYAAACJN7BNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABMWElEQVR4nO2dd5gUxdbG37ML7JKjKIq4KKCAICqIgCgYEEQRvSgqBhTlYkL9DIDeqxhQzAEDoGC6YEJERFQEQYKBHAQkSljissCSdnfS+f7onpmeme6Z7pmemd7Z83uefWa6urr6dG9Pna6qU28RM0MQBEEQEiUr3QYIgiAImYE4FEEQBMEWxKEIgiAItiAORRAEQbAFcSiCIAiCLYhDEQRBEGyhQroNSBf16tXjvLy8dJshCIJQpliyZMk+Zj5Ob1+5dSh5eXlYvHhxus0QBEEoUxDRVqN9ZbbLi4iqEtFiIrpS3W5ERFOIaDwRDU23fYIgCOUNxzgU1RHsJaK/wtK7E9E6ItoY5iiGAPhSs90KwCRmvgPA2SkwWRAEQdDgGIcC4CMA3bUJRJQN4B0APQC0AHAjEbUgossArAGwV5P9DwADiOgXAD+mxGJBEAQhgGPGUJh5LhHlhSWfB2AjM28GACL6HMDVAKoBqArFyRQT0XQAtwN4Si1nEoAPU2a8IAiOxe12Iz8/HyUlJek2pUyRm5uLhg0bomLFiqaPcYxDMeAkANs12/kA2jPzfQBARP0B7GNmHxH9CGA4Ed0EYIteYUQ0EMBAAGjUqFESzRYEwSnk5+ejevXqyMvLAxGl25wyATOjsLAQ+fn5aNy4senjnO5QosLMH2m+/wWgT4z8YwGMBYC2bduKzLIglANKSkrEmViEiFC3bl0UFBRYOs5JYyh67ABwsma7oZomCIJgGnEm1onnnjndoSwC0JSIGhNRJQA3AJiaZpuss34GUJSfbisEQUgTRISHH344sP3KK69g+PDhSTvf8uXLMX369MD21KlTMXLkSABAQUEB2rdvj7PPPhvz5s3DV199hebNm6Nr164Jn9cxDoWIPgPwO4DTiSifiAYwswfAfQB+ArAWwJfMvDqddsbFxOuAsYn/swRBKJvk5ORg8uTJ2LdvX0rOF+5QevXqhaFDlVkXs2bNQqtWrbBs2TJ07twZ48aNw/vvv4/Zs2cnfF7HjKEw840G6dMBTNfbVyYoPax8Ht0bPZ8gCBlLhQoVMHDgQLz++usYMWJEyL4tW7bgjjvuwL59+3Dcccfhww8/RKNGjdC/f3/UqFEDixcvxu7du/HSSy+hT5/IYeKvvvoKTz/9NLKzs1GzZk3MnDkTTz75JIqLizF//nwMGzYMxcXFWLx4Me6880489thjge1rrrkG8+fPx4ABA9CrVy+8/PLLCV2nY1ooGctrLZXP7ErptUMQhLRy7733YsKECSgqKgpJv//++3Hbbbdh5cqV6NevHwYPHhzYt2vXLsyfPx/Tpk0LtDDCeeaZZ/DTTz9hxYoVmDp1KipVqoRnnnkGffv2xfLly9G3b99A3jZt2oTse+qpp9C2bVtMmDAhYWcCOKiFkrGUqg+P15VeOwRBwNPfrcaanYdsLbPFiTXw1FUtY+arUaMGbr31Vrz11luoXLlyIP3333/H5MmTAQC33HILHnvsscC+3r17IysrCy1atMCePXt0y+3UqRP69++P66+/Htdee22CV5MYZbaFoqPl1YWI5hHRaCLqkl7rBEEQInnwwQcxbtw4HD161FT+nJycwHdmZabDE088gTZt2qBNmzYAgNGjR+O5557D9u3bce6556KwsNB2u83imBYKEY0HcCWAvcx8pia9O4A3AWQD+ICZR6q7wrW8GMARALlQJkCmn9/eTrcFgiBoMNOSSCZ16tTB9ddfj3HjxuGOO+4AAHTs2BGff/45brnlFkyYMAGdO3eOWsaIESNCxmE2bdqE9u3bo3379vjhhx+wfft2VK9eHYcPH07qtejhpBbKR0hMy2seM/eA4mieTonF0di+EJjxRLqtEATBYTz88MMh0V6jRo3Chx9+iNatW+PTTz/Fm2++aam8Rx99FK1atcKZZ56Jjh074qyzzkLXrl2xZs0atGnTBl988YXdl2AI+ZtRTkDV8prmb6EQUQcAw5n5cnV7mJo1RMsLwDXM7FPzVAIwkZmjzppv27YtJ3U9lOE1ddKKItMEQUgqa9euRfPmzdNtRplE794R0RJmbquX3zFdXgZY0fK6FsDlAGoB0O1rEi0vQRCE5OF0hxKVMC2vyQAmx8gvWl6CIAhJwkljKHqUTS0vnzfdFgiCIKQcpzuUsqnlNfeVdFsgCIKQchzjUDJKy2vO8+m2QBAEIeU4ZgwlI7S83MXAiBPSbYUgCEJacEwLJSM4tDPdFgiC4FBGjBiBli1bonXr1mjTpg3+/PNPvPHGGzh27FggzxVXXIGDBw8CAN566y00b94c/fr1Q2lpKS699NKUzyuximNaKGWWTbOBT3sD9y0WAUhBEHT5/fffMW3aNCxduhQ5OTnYt28fXC4X+vbti5tvvhlVqlQBgBDJ+XfffRczZ85Ew4YN8ccffwBQZOmdjLRQEmXVJOXz23uBN1un1xZBEBzJrl27UK9evYA2V7169TBp0iTs3LkTXbt2DSxulZeXh3379mHQoEHYvHkzevTogRdffBE333wzFi1ahDZt2mDTpk3pvJSolFmHoiMO2ZuI3ieiL4ioW8oN2v5n7Dwuc4JwgiBkFt26dcP27dvRrFkz3HPPPfj1118xePBgnHjiiZg9e3bE4lajR48O7BsyZAg++OADdO7cGcuXL8dpp52WpquIjWO6vBIVh2TmKQCmEFFtAK8AmJESw3csMZ/34Hag/hnJs0UQhOj8MBTYvcreMk9oBfQYGTVLtWrVsGTJEsybNw+zZ89G3759A0vyZhKOcShQxCHfBvCJP0EjDnkZFNmVRUQ0FYokyxooysLh/Ec9JjUUrI2+v9fbwNT7lO9EybdHEARHkp2djS5duqBLly5o1aoVPv7443SbZDuOcSjMPFcVh9RyHoCNzLwZAIjocwBXI0wckoimQ5GvHwngB2ZemjLDo3HREOCcW4IOBeJQBCGtxGhJJIt169YhKysLTZs2BaAMrp9yyinYsmULDh8+jHr16qXFLrtxjEMxwIo45GAAlwKoSURNmHl0eGEpF4es3iDcgOSfUxAEx3HkyBHcf//9OHjwICpUqIAmTZpg7Nix+Oyzz9C9e/fAeElZx+ny9X0AdGfmO9XtW6BxKIlgm3y9nky9nycPAFlZwTz9pwN5nRI/pyAIphH5+vixKl/v9CivsikO6Scr7PZOHpgeOwRBEFKA0x1K2RSHNMJ9LHYeQRCEMopjHEpGiUMKgiCUQxwzKJ8R4pAxcc54lSCUJ5gZJEExlohnfN0xLZSMo2G7yDRl2XtBEFJIbm4uCgsL46ogyyvMjMLCQuTm6k31M8YxLZQyz1k3ASsmBrdzdaK/5IEWhJTTsGFD5Ofno6CgIN2mlClyc3PRsGFDS8eUSYdCRM0BPACgHoBZzPweEbUAMBxAoZo2KaVGtb096FA63Adc8FBkHnEogpByKlasiMaNG6fbjHKBY7q8iGg8Ee0lor/C0rsT0Toi2khEQwGAmdcy8yAA1wPwT+zoAWAUM98N4NaUGg8AVeoCNU5Svp9/N1BVb+arOBRBEDIXxzgUKFpe3bUJGi2vHlBkVm5UWyIgol4AvkdwwP5TADcQ0csA6qbI5iDVo6zUeP49yqeMoQiCkME4xqEw81wA+8OSA1pezOwC4NfyAjNPZeYeAPqp23uZ+V4AQwHsS53lKpWqGu/LylY+pctLEIQMxuljKLpaXkTUBcC1AHKgtlBU2ZbHoYhGvqxXWMq1vIJnVj/FoQiCkLk43aHowsxzAMwJS9sC1VlEOW4sgLGAouVlu2FnXgv8NgrIqRGaTmpDULq8BEHIYBzT5WVA2dLyuvQZYOg2IFcciiAI5Q+nO5SypeWVlaU//8Q/Q9fnSa09giAIKcQxDiWztbxE8kEQhMzHMWMoGa3ldW5/YN4r6bZCEAQhqTimhZLRVD0u3RYIgiAkHXEoqUBUTgVBKAeIQ0kJ4lAEQch8HDOGYgUDccgsAM8CqAFgMTN/nE4bQyDx24IgZD6OqelsEIe8Gso8FTeUGfXOQbq8BEEoBzjGoSBxccjTAfzGzP8H4O4U2WwScSiCIGQ+jnEoiYpDQmmVHFC/e1NgsnmkhSIIQjnA6WMopsUhAUwGMIqIOgOYq1dY2sQhtQ6FWRyMIAgZidMdii4G4pDHAAyIcVxyxSHNsPJL4Ky+aTm1IAhCMnFMl5cBZUsc0gyHnBUvIAiCYBdOdyhlSxzSFNLdJQhCZuIYh5LZ4pBaZJEtQRAyE8eMoWS0OKQgCEI5wDEtlHKDrCsvCEKGIg4l5YhDEQQhMymTDoWImhPRaCKaRER3G6U5EvEngiBkKI5xKIlqeRnoezkQ8SiCIGQmjnEoSFzLSzfNccgYiiAIGYpjHIoNWl66ac5DHIogCJmJY8KGDTCt5WWg7xVC2rS8BEEQygFOdyi6GGh5RaTpHGevlpe7xPox0uUlCEKG4pguLwOcreU162nzebs+oXwe3zI5tgiCIKQZpzsUZ2t57bGgApPXWfnMqZYcWwRBENKMYxxKmdTyOvCP+byyBoogCBmOY8ZQyqSW18Ft5vP6POox26PnEwRBKKM4poWS8fyjLiL53eD02iEIgpAkxKEIgiAItuCYLi8rEFFzAA8AqAdgFjO/R0RVAbwLwAVgDjNPSKeNkcgYiiAImY1jWiiJanlBmdQ4iZnvAtArpcabQQblBUHIcBzjUJC4lldDBGfVe5NurddjKXux25ckQwRBEJyBYxyKDVpe+VCcCpCK6yopspT9vTmbkmSIIAiCM3D6GIppLS8AkwG8TUQ9AXynV5itWl6Hd1nKLoIrgiBkOk53KLoYaHkdBXB7jOPs0/Lauzb4/dQu1o6d/ihwxcsJnV4QBMFpOKbLywDnanlVOy74vduImNlZG+W1cGwSDBIEQUgvTncoztXy0qoGm4jgYgkbFgQhw3GMQylzWl7s0/+ul5VZxlAEQch4HDOGUva0vDQuIqti9JziTQRBKAc4poVS5tA6ifpnmDhAurwEQchsxKHEjflmBwM4itzkmSIIguAAxKHEi4V+LGbGt96OSTRGEAQh/ZRJh0JEvYnofSL6goi6qWmdiWg0EX1ARL8l34pQh/Lzmj1o9dRPKHbpq754kZ18kwRBENKIYxyKRXHIKaoI5CAAfdW0eapg5DQAHyfd4LAWysgf1uJwqQf5B45FZoXMlBcEIfNxjEOBRXFIlf+o+7XcBGBi8sz0o7qI26bB4/VhU8FRAMBlr8+FzxfpPmQeiiAImY5jHIoVcUhSeBHAD8y81J+ZiBoBKGLmwykwWPnMqYb1e46E7Lr/82URWcWhCIKQ6TjGoRigJw55EoD7AVwKoA8RDdLsHwDgQ6PCiGggES0mosUFBQUJmuZvhRC8YS2S71fuCsvJ8IlDEQQhw3HMxEYrMPNbAN7SSX8qxnH2iUOqLZSVOw5h3pFI55Q39HsAwO/DLlayi0MRBCHDcbpDca44pNpCGTp5FdZE6WG7cewf2FJ4DDmpMksQBCFNxOzyIqLL1BDdNur2QDP7bMLx4pCxWh5bCiOjvgAAw2sCvzxnt1WCIAhpw8wYyh0AHgVwMxFdDKCNyX2WKHPikDDnUPx49W71XFkTRRCEzMFMl9dhZj4I4BEiGgmgncl9lihz4pCBFoo5PI7vXRQEQUgMMy2U7/1fmHkogE9M7stwrLVQBEEQMp2YDoWZvw3bHmVmX8ZjcgxFEAShvGCqH0adMGiGg8x8KAF7TEFEvQH0BFADwDhmnqGmVwXwK4DhzDwtuVbod3mdVKsydhwsTu6pBUEQHIjZjn0z2lgMRT4lrm4vIhoP4EoAe5n5TE16dwBvAsgG8AEzj2TmKQCmEFFtAK8AmKFmHwLgy3jObxWfj5GFyBbKa9efhb5j/0iFCYIgCI7ClENh5q7JNgSKM3obGoek0fK6DMos+UVENJWZ16hZAlpeRHQZgDVAahYeOVziQs2wtGo5FZBbUVSFBUEonzimy4uZ5xJRXlhyQMtLtcOv5bUWwEiEanl1AVAViohkMRFNZ46x2HsCbCs8hlYIbaGc17gOWp0U7mYEQRDKB47p8jJAT8urPYJaXjWJqAkzj2bmJwCAiPoD2KfnTNSJlwMBoFEjsz5SH3/xWo2ut286G1lZMkgvCEL5JKEuLyLKYeZSe00yZY+ulpe676Mox9mo5aU4FG0LpUol5XbKwLwgCOWRRNWGh/u/EFGnBMvSw7FaXrWqVASgHzZM0kgRBKEckqhD+UmVhO8HZREsu3GslldWWNiw38EAxsvNb67QJMlWCYIgpI+4HQoRjQPQC8CNAM5k5v8kYkhZ0/LisImNvw292DDvC9e2AgA8V++l5BsmCIKQJuIWmGLmAURUGcA5ANoR0Rhm/ncC5ZUpLS+fzz/mrzgU//gJEOzyat6gBtbuOoSup9fHeXl1cMzpy5kJgiAkQEKKhcxcDGCB+leuOObyANDv3nqpT2u8+OM6fHL7eViz6xBOqJkLkHFXmCAIQiZg6Z2ZiHoQ0Z9EtI6IviSiDskyzOl8uOAfAPqD8h1Pq4dv7+2EmlUqosNpdQFAFL8EQch4rHbCvAvg/wCcDyX89mUi0u2qynT8DsKKOGTMBkrpEWBlSpRjBEEQbMeqQ9nLzAuY+QAzzwRwOYAnkmBXVIiot7pS5BdE1E1NO5WIxhHRpJTYYCAOaZifTGT+/v+AyXcB+UsSMU0QBCEtWHUo/xDRc2oILwC4AXjsMISIxhPRXiL6Kyy9u9rFtpGIhgIAM09h5rsADALQV03bzMwD7LDFlL0W10Mho3xH9gIbfgZcx4AidYqN+6gdJgqCIKQUqw7FB+AaANuJaD6AjQDmEFFTG2z5CEB3bYJGHLIHFI2uG4mohSZLQBwy1Wi7vLaM7GnqGNZrorx/MTChD/B6CwSbMCa70bb+rqxNv32hufyCIAhJxJJDYeabmLklgEYAHoAyU54AvE9E2xIxhJnnAtgflhwQh2RmFwC/OCQR0YsIFYdMKf4Wyrv9zjWX3yjKq0iVKis+YN2ITbOUz81zYudd+gnw9Z3WzyEIgmCSRNSGCwDMVP9IzVfD5gW2TItDElFdACMAnE1Ew5j5BZ3rsE0c0u9QKmSb88lEJsZbdlgcO7EShzz1fuXzXx9YO4cgCIJJ7FAb1tZqHyEF68rriUMycyGUMZVox9knDukv02TvlOEYihZPiZrZYpDx0k+Bix6zdowgCILNOGmBLT0cKw4ZGJQ361EQlGuJyabZQN4F5o0p2qZ0mVWubf4YQRAEm3HMAlsGBMQhoTiSGwDcZGP5cfNsxY8AWAsbNt0kmvcKcMl/rRnkS9paYqml+KBys3JloTJBKGs4ZoEtVRyyC4B6RJQP4ClmHkdEfnHIbADjnSIO6TwyRNflxVOUz+FF6bVDEATLOKbLq6yJQ/pp07CG6byWtLzeOR+4+zcgy2Jk9/CawIWPAhcnJP4sCIJgGdG/TZBsmOtqIiJrbYiCtfFPcJz7cnzHCYIgJIA4lETxeU1li0sc0uNS/g7v0d9f8Hfwu0gZC4KQZsqkQ9HT7SKiRkQ0RZVwGZoyY2qcaD6v1Urf6wK+HgC82kzZLtwUWsbf06yVV55ZNUkZ8BcEIWk4xqFY1PLS0+1qBWASM98B4OykGqut1LOyTR1iKcrLj88NrFVXPN44Exh1DrB4nNVSjFnwJrDGESsqJ5eCdYpjnnJPui0RhIzGMQ4F8Wl5afkDwAAi+gXAj0m0E/C6AQA/5XQzfUhcXV5vtAp+/9+/lE9DJWK23gL6+Ungy1visaxs4T6mfB7KT68dgpDhOMahWNHyMijidiihxhcDMKfWGC9eFwBgR3ZDS4fZMsyxYiLgtUXgufwh40zlk4+uBH5K+Sob5RLHOBQD9LS8TiKiukQ0Gqpul7rvRwCD1fQteoUR0UAiWkxEiwsKCuK3ipXILibzt0+J8mJg4K/xn9fPFAOFGakwDZD1Mss1W+YBv7+dbivKBQmtKZ8u9HS7mPkvAH1iHGePlhf7I7ssOBSo9f2JbeI+bYDNOk7JqjNxHUvcDkEQBA1Ob6E4U8tLrbx9lloomo2zHTBusXl2ui1IA9KCE4Rk4nSHEtDyUleJvAFA+sOS1C4vWHAogKYRkRSdKoZUmIIgpBPHOBRVy+t3AKcTUT4RDWBmDwC/ltdaAF86QsvLP4ZiqW9eM1OeHSbkuFbms6D4gMxTAYBDu5TF2AQhDhzjUJj5RmZuwMwVmbkhM49T06czczNmPo2ZR6TbTgBxDsprNk48J3EbinR6/uIdlP+iX2K2hFOUD+xaYW+ZdrB7FbDwff19L+YFhSnLMxP6KIuxHUkgaEUotzjGoZQpVIeSbUG4scTtxZ5D6gJara9L7PzeUmDW02E2ceR21Eohgcinwk3AsfAIbw2vtwTGXBh/+clk+iPptsDZHFWfGZ+Epjsar0cRgl3wVuy8KUQcSjyoDqXYwm9u3oZ92H/UZc/5S4qAlV+EGxW6ueAN4JUmwIEtoembfwW2/p7Y+UedA7zXMbEytMx7Ddj2h33lhWN1BcxyjdyrqOz+C1j7XbqtADzFyuevL6bXjjDEocSD6lDqVc9NsyHhaJzK+hnKZ1HY7PBPegEfdodlNv0C/DMvuH14l/UyjJj1NDD+cvvKE2xAAjx0Gd0J+OLmdFvhWMqkQzEQh+xCRPOIaDQRdUmqAarCsJUxlJSz7Tf1i01vnJ9eA3x8pT1lmWHjTOCDy0yrOZcbig8CG2Ymr3xpzQkJ4Jga0QZxSAZwBEAulBn1ySMQpeWY26eMmRgNypfYuSpzipg8EMhfGDpWc2ArMOM/cSx37KBKMn8JcGRv/Md/dRsw4V/JHzQX1QUhDhxUIyYsDjmPmXsAGALgaYM89qD+2BzVQmGDN3kiYIYJHSOfD/j1ZeBoobLtLla6uKJVLPs2WLczEb7qD/w2CtizKrXntZMPLgbe6xT/8f577i21x54IHOR8zbBqkjI47S5OtyXpwWGO3zE1YqLikMyBZsMBADlJMxSIK2w46fi8wNYF+vtKD8c+ftVXwOzngO8GK9sjTlC6uFZ8bnzM222t2+mnpMhc1422C8bnjv98TuJoAi2UlOGsisqQX55VPu0c08skig8C+zen7HQOqhF1MS0OSUTXEtEYAJ8C0FWCs10c0klvc64jwKe94z9+zgvKpztM46swSa2QSXcoXTeHd0fP57A3sIxHxlBST+lhYOOs+I6N9f8a0xl4K7nLQ2nJJHHIyQAmxzjOJnHI+KRXkorVJv+Sj0K3/deiV4FbHrMwQeFG5VPrwA5u0xpkfKxVJxPrRycD/5GUNUde1uzV8s0gZfXVB/8Cap0cO7+WWNcd8ptKPg6qEXVxqDikv4XioNtnOBHNoDLd8FNYNoN8R/YCz9SO26wAR/cp3VyB8+k4MO2CYrqE2Vh6BPhhSOLKyZ8YLbFjA4WbgL1r7S/30K7AQm/2Ii2UlFOwTvkM7x0ogzioRtTF4eKQNv34TmideBnR3rIPWehf3jw7VNMqfGLk8DiFLV8+DXjldE2Ceu9i6ppFeQNb8Abw52hg4dhg2uZfgaWfKtFgZt9at8yLnSdeRp0DvHu+feX5r2ncpcC0B+0rN/JESSxbw64VwIuNReolXhzWRekYh1IWxSHj6fLy+nR+qBWrJGgQjOeI/DQM2G5iFrr2WiJm4duER9MtF62LDYjxQ1GP8b+hayPcPukFTL1PiQbLgDe+qPw93f4yU11B/TYKKN6fwHIK9th78JgLo2ZtgE/v95lsErnnDuvqc4xDKVvikPFPbPxgnk7EhdcmSRY9di4zmTEJFcn+fyLTdixVWhFksoUS7QfjOqJ8GkWi/RV1SC0xFo1TWmueJP7v0onRfXcdA75/JHRu0/w3lK49O863/DNgjU4nxOHdyrNjxMaZwL6NcZ/+v9+uxqs/r8fcDWloKTnMKSSCYxxKmcK/wFYct+/v3TohvO3/nahFySPW29M75wPbF+k7rrfaRKa931VpRQRaKAYOxS9S+Jue+J1q0z9zlc996/XLKClSulQK469oDPnlOeWzNJ2TRqNURD6fseLzii8ixTv/ng682yG2g1/0AbDofWD+a8p28UFg5lPKuu12MGUQ8KXOAnRvt1OeHUBpmYZXwj88Brx9btynPVaqjEF6vJlTuacDcSjxkECX1zfLdmDfkbBJaXVOs8GoBNE6jh8eM39cwVqlP39sl+gKxBHn89+7GD/gbVGELI0cSQBWKs6v+pu3KxpetyJ/79UGQKSxDzvam+2C15Vr374oct83AxVnM+7yYATft/cAe9doAicMyvY/+4ExOzWf+2hovoPbFbke0yoNDIzvob/L5ws67mP7gWfrGbxoJE7c7uSfuUqL1cp4ZUI4a+zET5l0KAZaXr2J6H0i+oKIuiXVgAQnNu49FOZQqtVP1CIbsOEBfamxMtveCrGa+7r7DY4J7/Kwqyvhn3lKZfH1nYr8/eLxQRu0jrjkkLI41U8mlAmM2LUisaiw4gNKN5y/dVK03Tjv9j8SGGdSr9/oHs95QREUHXmy4lwMUe+fz6PRnwtDG2U4+S7lc/ln0c3bMl/5n+3+K3o+u/AHhuQvTKAQK79BZ7akHONQEtXyYuYpzHwXlPkpfZNqrB1RXtd9DLS7C2h5DRzxcBRbaF1EY/Zzods+H7DgTZ2M6r2zMn4U635//1Do9s//NV92NDb+rHz6ZctLioIV6UuNg5Xb+12Vxal+151Xa44xFyYWFfZiHvD5jTBdOfkDGooPqAn+sS2rwRLh6Zrt1d+Ys8UMG00KY/r/V2Yi+DylqORT1ipy5nt/2cExDgWJa3n5+Y96TPKwQxyyZW+g5yvAdR85Y1DuyJ7klLvpF+DnJyPT96rBev5+cUN07o3eYD9g/308th/wmNDMWvqx8mllrCbWipZH9pqYZ2JwvRtnAmummLMj3kmdlu51Gp5vK/a92QbvbVPGgGy1dOtvxs9qhuIYh5KolhcpvAjgB2aOEg5ih7F2a3k5wKEY4R/4jhdPSWLH61UMk24Pilgmk5caAxOvD26HvJ1r7TLxXrsnLNp9zIWA66gyOXPv35H5X2kKTLknuL3og8iBb+1E0XgxHIQ3eiZNvsPrZfviZmDdj/r51/2gn27YurHxN3N4Z+Jl+J9TrYTKhz30A1MiD078/LFY+mnyzwEHORQDTGt5AbgfwKUA+hDRIOhgm5bXjiUAgFzfkbgO//SPrSg6pnn7dEILJVkkGmGlrfC0b/WlNlSmeuxeFdoy2DxHz6gwf2KiktVb4fL5E4EXTgLeba84l3DWasJnv384rgmYOw/GcOhWWyimu3k1+fzP99rvgM8MeqP/nhaZ5imNHVChZ4/PB+xeacrKiOLiOkqDv7WqZeINgDvBF6tEmXpfSk7jdIeiCzMXMvMgdW7KC2raW8x8rpo+2uC4sczclpnbHnfccfEbMHM4AKDRkfgG/D5buA33TFwS//nLEjOfSuz4wk3A+O72SuX7Z2WXFEUO5I++AJhhNPaiVjfzXgt1aFsXJD4fZWyXxI43gA/FqVRk9iXHny8ZEyKjObto9v3xbvToQAPOpXW49MtmwHYTA+vhc2KiXf/6H4L2eEp11sMxee/mvgK8dKry3aEvoU53KM7U8lLhrOy4j12/R9O6cejD4QjcR5Uf48dXhaZPuiN0+/tHzL/BT7pd+RzfXX/uwoafgJmaJXXCu5Y8OkKca741d24j9EKgbXguTlr4XOxMWsw6hoBtZgbvoyz+FjdRyouzdXJRttoC3mRi1n4giMEin9+kdGfGwy/PAscKY99Ljwv4c0xYeHtqcLpDcaaWl4o7K/415QsOl2JTgepUcqpHZhi8PO6yM5Lw9S7CJ1Iuet98WVvmKdFYe9fo79+/OThxDzD3wzRa4MwKWg21VKI3+M9soGDtdxT+sGETStTsM5cvnGhLJxwrNIgehLn1f9KFmSi1wk3AtIeMW2ixHMovzypzyZZ+ZNm8RHGMQylTWl4qS+teFTuTSs3KFSPS1vtnzVc/HsjrHLqzSt1ETBNisfQTe8sL/5F/eIW5CDEtL54SXqjSOnqnfUKmhaDnJP76OjJt9ghlkbVYXTt6lZvrKLBpTnB71jPGlXy0FtHYKBGAxwqV6EG9xaPWJUHjDLD+/wyBoxwfdg8n3a7MdTKKBGRf6DH5S0Jb0f5Jn2lwrI5xKGVKy0vFk23jwpBNLwvdzqkOtL4BaKQzmCukFjO9QOFv4FsXAHtsmFT3SW+gQCcKLB5+eU5xEuHotVBWqzpoRmHdel1eB7cD2/5UWn9FYetwxDNGFE+rL8LBmR/b0V0w70hBsDX8XP2Q3CGYiYb8xWL3I6C0wiJWXdSc2+dWlpX+7MbIY8PvRemRpE/0dIxDKYt4KTGHckAb6XX+vUCfD4PbRMC1Y4BGNkqfC/HhX6Qo2hLEul06NgxU7zQRAT//jejLCkx/VPmca6BiYGlAPbyFornuN1sD47sBBTrjQQfC5mMs+x/w47DIfImy6AMbCtFUxKM7mXOGZkK4rQZIbJqltMJePCV01UXtPfevg6RGnmL3quC+WZpxQEAJ2x7dKamCpuJQ4uHk9ljGzcDZkd1YVvBp3yCyKwBnXgtQ2EC/0Y/9kSQtzStEYubtUy8sM/x/Z3VBLLMD2f5IOqP82vViIk8S2g0W65ykGUPx+YBDmjkcgYouWhnq8d/eq0Rj2U0s2ZrNv0ap/DX/ryN7gfmv2zfh18z/0n9v/V1dRi0arzvYfRb+IjP6AuPy/ZFmhovxJU5GOBQiakFEXxLRe0TUJ+knZMZRzrH0/qnnF7Yf0NFRGjQf6D5Se6Ty0e4u4I4ZwWRH6H8J0Qn7p/vlQBIirGLSThSMJ5Jq3qthAQ+xtNV8wXPNfw344BJlWxv1FNUOVkQjU4W2ZXRsv6J0/eWt0Y9hVjTD1OkBjmPSHXFGioUFVCQBxzoUK9peUKRZRjHz3QBiPC2Jc7SkFF4m/L45sdnaY37VGVA8vgVw/t0RySU5dTHj8CnABQ+h9KL/JHReIUWED3b7w5XNotfFFh7tpp0oGC2Symewb+HY0HkXrhiTdf2V7MIxUVo+MSqsTb9E358QYef+UzMlza8bZ9CKCTky1oB2tEs0jNbTabGu+TY4+bcoP/o5/YQv322WFCye5liHAmvaXp8CuIGIXgaQ9PCoI6VueJGF1TvNr4UR97+yqSKcPHJ9Awz8dAnG596G039qge9W2CAXISSXJEmsGxJtEPvNs4z3WZmBrxXzNOoOsmPOSTI1xo7sMQiJVtmxJHa30Bf9wpa01qDbAmNEeKG5r4S2lswKX+pCsRc5S8EKpo51KFa0vZh5LzPfC2AogH3Jto3YB1+qdEkbtQeGF+GXI0pI6bfLlYG9+z9bhk4lBnH4BhziyrabJziIaC2U8KirpGLFoRj8jpKx2qZ2aeujUaSXNv4c3eEAikbdkd36+8wEUhSsDwZ7+Em0BWGkhxbO8ycmLdrLsQ7FACNtrzwiGgvgEwCGC3LYpeWVxT6wxVtHBg9LqceL/Udd2HmwGGzi7WpFfnBAcQesycdcUPom0Oo6S8cIZYh43+rNsHg8MGlA7HyAtTDnrQv00+Ocie6LNgk1RPWalDBao3sWc/E2lQNbgPeiDISHoKkD3mmn8wKQoEOxMtjuX5LBZiokpdQUw8xbAAw0kW8sgLEA0LZt27jb5QQfvBYdiser//b470+XYM46xbm93Kc1rmt7sm6+RLnR9QQOoVp8M5aFskG4orGdTHsodp54MFoA7IdH4youa7lJVd0fhyqClGffHEhijqNC//0dYM+qyPTpYaueMoAN4ZV4WBVUsM76+bVEC2sPJ0lyT2WtheIIba+6RzeiGUVbhS6SQyX6bw9+ZwIAS7cF38oOlbhxuMRimGkUfve1VL6IbljmMj5JC5Vm4jPjVzde9j9z+Q27kwyc0MIxodubZ0cqZIe/3MU72A4o42eWWqjiUAAHaXudmmXQf5oQwYez9fAZaDV8RpS8xnQpfdV45yky816wSDLmizgQ3Znyfj67QT/dbDfTMZ2IUL3egnjlXbyu9GnBaXCsQ3GytlcRV8FEz8WWjnno0mam82pbJu/O2YgvFhkPqD7tviVke0zFW7CFGxgXftI5pu0QBADAT4+n24KUQPG8tS8eZ7r0CPQcynMJzC/78z3zeZPU6nTsGAoz64jTKNpeAJKk/mYONypYjvIafEkTvD4z+kCff9x+4CfBtVJe+lHpV21Up4ruMX/6mgMA1voaoYdrJCp5sgD48LX3Avwre37kAce3wmzvWejql+oWBCH56K3uavd4ZvOrLEyelS4vx0Dg6M1jvWNMhAT6c2jHUvyUeqL3j/rtcXmUh9TvaAAAF2gGVCtUwu3uIWhdYkHuXRD81DOYe5EBPFRRR3XZLvQW/LLboViV9kkC4lDigMCpm4eicrRU36EYiSnM9GoWjrp0eMRxh1DVFruEckZep3RbUDbZrzPp0O5up/U/xs6TZMShxEGW2kK584LGtpbrb8ToLpNt8PARlLec8BbTftSw1TZBAKDMRxHsIZ3Rc0k6dUY4FCLKIqIRRDSKiG5L+vlUh/L4Fc1jZ7bAwWNuFB7Rj/I45tJvoRRDkdDfxXUsn29OlcstHyMIgk3Yscpn/CdPSqmOdSgWxSGvhjInxQ1l9nxSySLg1OOqISvL3m6vaSt34dznZoIsdKdt4pPwoOsePOweFLHvxZzBQKcHDI8dV/dhXFb6Uly2CoKQIA7oorIbxzoUWBOHPB3Ab8z8fwAipXpthgD9qA27yrfop6b4LlBmwYfxY8VLgMueiX6uJEpZC4LgUMrbTHkr4pBQWiX+0KiktyMJPmSlQAo6UcxogwmCUB4pZw7FAF1xSACTAVxORKMAGC6vZ5c4JAFKv5fD2VIYXa46JJQ5N8oSslY46Vzdsh5olsw1MARBcAJlzaHowszHmHkAM9/PzO9EyTeWmdsyc9vjjrOm1KuFwMhKYpeX0QC8HRw8FlzPgqDp8qp+ItZcb6D8aoEjbmBi649D0uZ7W2LR1oNoV2L4rxEEIZWUty4vAxwhDknwJXUMJZmMDlsl0gNlDfsCTy7m76uMTb4GmOtthTYlY/QOj+Be1+CQ7bW7D+PxucGWUZOST3Crexh2FpWgALXNG6qdjCkIQpmgrNWKjhCHJDY3890JjPl1Ezq+MCuwzZq+0x0Hi7GJT8TGNkNxxa478fz0v3GJ61Xc6h6GbOjP4p3i7YgHqwWXnPned37Ifl/YI+VBhZC0fq5hWNbNxIzkNMvs/+wVzTMhkylnLRQni0MSGBRHC+XPxy/Bs1e3TIJFxrzww9/YWVQS2J62Irgm+ca9RwAQtp1xR0TrISvMoaz3nYR+rmEY5r4TU/adZHi+Tz2XRbVnga8VDteLshytyoaDMbMkjWW+JjiZ4h9jczqfebqm2wQhQ3GsQ2HmG5m5ATNXZOaGzDxOTZ/OzM2Y+TRmHpEm60BZ1m/d8TVycUuHPPvNscCOg5FLm77+84aINLeqG/qHrzk+8nTDta6nscDXCsXINSw7r2Qipvk6AABGe67E/zyXGOZ9/LRvDPft6vAUei4xbiG86+kFAPjbF7kY2Qyt5IwOpVwBfUqfjJpnma8JSlAxap5U8pHH3nVOJniN/y9lihoN021BmcUVQxswXhzrUJwKMyMLXGa6vMywakdRRNpBVEff0v9igOsRDPf0xxHoqx0bMdJzE/7jMV4y9nCFYItojKdnyL7tzfrDFaVCf8lzA04v+QhXuSLfJ3zIwqVRJmt+7zsfi/mMaKZjpu8c/OqL3YpKBnpO8mdfdCdplX2sH9H3tbezredJNr/UujbdJpRZil0Wlgu2gDgUi3hLj6IC+VDFE1kJZxp/cnMcRWXdfaM8vfG11+xa2qHsOFiM3UXF2OpT1n4oUeVjwhntuRLXl/43NPGmrwAApagENypgtOcqAIp8PwDM8p2NjRz7zTVkPZvuI0P2LfU1xX6OrYVWcmrslsMw9wB84zUvqNjd9WJE2t/qtdnBm55rsRt1dfcNc98ZokI9xWt+MbYrSp9HQZijGuy6Nz4jzdDjZczbFN+68+WBl9x9o+6vueiNpJw3IxwKETUnotFENImIkjpTnpd/DgBotXty3GX075hnkzXp41XP9XjYfU9cxw6bvAqLthxAH9dw3Oh6Au95rsJbnt6B/f7G30jPTVjIzbHAqxl3yqkeUtY835kAgLm+VmhZMg5febvo2+vuE3ZcKwDAnobdgfNDHxkGYaKJbqHf/jmkm96yJHTRJatLHYRTCJvmCAE4EfsM97mRHaJCvczX1HS5u7kOJoe9YEz1dUIhVzc4In52tbobaD8Qx6J0v5Z3ZtjcqjWLYx2KFS0vZl7LzIMAXA8gqfraRqq/VqhUwbG3PW5+9LazfEwBauF3X0uUIAevea43zNfP/QQ6lIzClqb98e6mUBHMBb4zMcj1IF7x9NVtTV1Q+gZalXyAHVwPQDC2ZabvXEz0dMW9+/vilnF/RhznMfHTWOeOPZeJAGznyHy7OXYIdV7JBDQuMbnmeRjjPd110xuSsUPhsGs2WqIhvIsSAA6hCmZ420akv6N5UbCLKcvysWXfUUvHFLG1LlsAeNNzjeVjzDDEfVdSytWifYm5tnR40s/nx8k120cwr+UFIuoF4HskeTVHX5rDWZ1IXslEDHInPm/kTc+1eNJ9m241tgt1ceX6K/DSjI1hewg/+s4LBBGEk8/1cRhVIsp0owIe99yFxftzMG9DZCUbXrmu9Z2MNb5TkFcyMZD2vk7FqlgUfOnQjkv8z3NJoPtLr/I9FFHpUcCOiK4/IOpY0Ruef+mmh78O7eVaAIAfdF4IFvv0F9N6zXMdAMDDWejvehTXlD4NDyrotsQ+9tobUAAAW/gEvDtno6XAV6PnIxprfKdEpH3m6YpV50V2S1phnc44Wbx8a9AtuYdrY5NPWQp8KTfFfo7U+ksGjnUoFrW8wMxTmbkHgH7JtMvnS7yFIhpb+rzu6YNPvJdjc4H+2+eR0vgHEpfzaQCAn0y0pPQEM3u4XsQVrhdC0sysOVOKSoHy9nJtPO4egNtdj2IdR1Yq29h4PfGF3BybfScEtl919zE1VhTOgTAR0afcxqs9rOXIChUIvv0yCHN8Z2MZK11jq/hUAICLswPOTutk8tVWoh5HWX8cTQ8fCFlElroS4/nFaedPlbISJPK973w89Hf8y1Z0KX010Fq2gwfc92FbpSYR6UdQBX1dT+Jm1zAAhLGeK207ZzQc61AM0NXyIqIuRPQWEY1BlBaKHVpePl/i4XbiT6Lz2NcrbS9zE5+ExiX/wwyfvkN52n1L4Ls/wqxX6bO6eS8qfQ0dS94CgEBggRZ/NXeYI7vgipGL2b6zdSOqYik/+yvQXqXPYpRXiXDStpj08no4C/9x3x5I/1DtCvvee17IfJRYlbPetYR3iblRAR1L3kKr0nEBZ2f2Uf8/d+g4ll7rwA+B8fmi7Yb7jY7y86fvDPzly0PzkuiLhRl1+SnztyLZFxbIMdpzZUSgwhZuEDHHK1EOl+gv/bsPNTFfHSsc7e1l6zmNKGsORRdmnsPMg5n538nW8vJ5Eg+3E3+SHsK7sbR86O0R+O5/M13Jp+HC0tfRN6y7aSufgJ1Q3jIvcr2BFb5TQ/a7VTmbJb5m6nkjKya9yLYsk0/G0bDB6Giz+o8hB//zBieb+kOm73U/iGGeu2I6scfdA9T8QYkd//Ws4byI/DtRD6WoFJEXAO5yPWx4nsKwyji8ctbD32owg9aO212P4UrX8zGdaLjqg1KOPo+7B+CS0ldC0kZ6bkK70vci8u6BucXwlvkiWx524ePkTHsoaw4l7Vpey7cZD2qaRVooZYdtfDz+5OhdHOFvnCXIQc/S53GPW1nczOyaMyVqRXxB6RvoVhrZT++vAMPLm+NrA0CpJO5wPYKepc+bOp+2TKO38YneS3Bqyf+wwRfsXnOjAq4v/S/6ux4zcYZguWv5lEDL7BH3v/G372Ss9p2Cq0ufiepMV/nydEuc42uDtb5GeMClH23YQtMC0Std61C+9nbGra4hIfvX+hphtleZjxRroutOrosinTWJ4qXw4pdxg+s/EekzvWdHPa7EpJN9xP3vuOyKRVlzKGnX8io8FF0S3gzNG9gfSimEstx3KqZ6O6TkXNma6mqbT2n5rua8QFjr915F72y677yQ49b7FAmbHazMC/FHFeVzfazXGWMxeqNeqob3DnA/gl9852A15wUcxOEYE1KVaLeL8XSUsRQfsiKc2EJubqkCfcPjn4SolONjQnfXi+jpegEruAmyKLT8UrUCv9U1BH1cw3XLPISq6OEaGXGv/N1M2rDiN3WCFLR6dW97emOu7yz82/VgIG036uIB9314zH0X/vI11rXBzUpr1Ew3ll5ghRFEWSEtvd1cG61KPsBd7ocxIEpLr797CJqWfBKS9v1gJZzbi2zsPq4T8komYrLvQtO2WMGxDsWpWl5eyk64jD7nimREsunteg6D3fdbOuZO18Mo6P255XMdUCNoepaOwKWuVyL2r+NGyCuZGDGI3s31MvJKJgYcwi7Wn3Do5zdfCwBAEVcNSV/Lp+C0kk8x2xd8ez2KynjKfZvuW64WJdrtThSgVtR84YP5ZunfMQ95JRPxhkeZB+R3ieHOMdxhPe6+E+97rsB8XyuUohKalnyC+d7oOnh7uRaed9+IdqXv4pzsSQCAh1x341tvx5B5Rf5zHdN0O/odwk9hTv8QquJLr/FY09tqWLQ/Wm5Wpwlwdx6CTytFhsEvNGjp/uZtEfg+z3tmwEot55e+g8OoAkYWZoXNMdHmdHN2RERbyxNr4qPb28H9RAFOuFcZYr6362m6tiSK9Vi6FMHMNxqkT0eSQ4Oj0avP7cCYMfDWaYJ4XUsmybZkEjN95+LZxl0AWFsMbLD7PnT3LcJq1n+LjcXj7jvxg/c8rOPoM+Kf9dyC8d4eussAeHWexo+9l8dlz2jPlRGTGqNpuEWjYe3QwXx/qyC8i83FwapoP1dDAWphhOfmQJobFZCvzucJdz7+eT7Pum/Gdz4ljNYfSfmNrzO+8RlJyhDudD2M1yq+GzPyyqjbcpT3Gsz0nYvV6njSWR0uQ8VqV+LCNkeBl+cAAHZyHZxIoQGrvUqfxdQcpcUyyP0QVmYnPjflW29HLOFmIWnXt1VeYrqcHgweIULSVpx1rENxKjkVlB9utjiFjKNp/Wpx/dAKURMTvJeazt+8QQ2s3RWcZX8YVTA9bBkAPTyogK0cDB2ullMhoVBqI0Z6btJN/8LTBQ0tqjCHvzz5q+USTXcOACzhZnjW3Q+TvBcZdqV94L0CXbJXYGaYAOgRVDGMdvuwfzvc/tEiQ/tm+s5F69JQZYNupS/irKxNuvnDWyg+ZAWcCRBsLZxStypOrJmLnUUluKj0jYgusZV8Gg5yVdSioziEqtjNtXECaaRk4ngOx3iuBECoUikbx1xenNOoFl7qE6lJR0jeOK44FAdRI7cCDpUkR7RNiE313AqokIKlnb0+e8JGrVh6XemT6JC9JqHzDfEMDHzv2boBvl+5K0puhfDb+Yz7VhRwLcyMkAYhjPPqTxT1s5Eb4vxSa6t+1qwSHKT+/uyxqLR4TEhXlx7r+WSs94aOy8TzVNSqUgk7i0oMJ1VeXPoqapESguwLC7ionhu/2nXT46vj87vOR4VsfauVOTzlbD2U8kjP1idG3T/65sxd9GnABfF1F9lJFhHqVjM/wS5e7r/YvEZWNKy8xC7iMwJzVwCg11nRnzW7CDdxP2pghOfmiC66YT2CCtB1qlZCovirS+2b+J665+Eu98NRw8e1nFgz2M1X2GEYfHVOwwpf9LEHre3dzzwhSk7lXmxm5f9wq2soxnp6YpZP+Y1XrHcq7u5yGmZ6z7YuwsqMypWyUTFb/zqJABvmZ+siDsVBtDwxeux9ozpVo+73c1ZD+8QErTK0h7E0/HmNjePvr26TmgouGsnqVw7nqhiVeW+T98LsWNypxynPjbZyrVUl/jdgIPob+91dgpVulokW3/InL8MlzY8PbM94KDQC6dpzjBd00+Olf7XWbAUv2uq/V3t/S44/B667F0UVpGyXVzvkmPu6NsGjl+vL14SzkRvieU8/fOjtjqO3zwHyOmFI9zNwp/vREBHWd/tFvlQeUW3yL+cdy1cQKGldXhnhUIioKhF9TETvE1FSpVeSSbeWxxvuW/hEMErljBOCYccbRvSIzJzi8Z32GkdRyeCtqFGdKnjwEv0380rZWWjdsFZIWt2qldD2FAtr0FukSqX4Qipuam+flLwRFbOzAv/CWzsYzxiPVVf3bN0Alzavj2/uidRL1Tr3U+paF040SywnfepxVVGrSqWQR7ZeWCvxiSvMS508cElTXN/u5ECFqa04E3lhaFAzN8TGAa6HI7TUKMzNZmURalS26rgJlRoGxz3+dU5DNDu+GhrWroyK2YQrWjUI7FuqTny8zzUYI903YL1fnSC2Ryl/XV5W1IYBXAtgEjPfBSA1GgMJMvP/LkKLBkqLpF61Shh149moXz3y7Wf0zediy8ieuvsA6DZrUzEO4Ofhy5rhi393CFRuRkrKcx/rqrtvy8ieWK/jFCff0xHv3xopoOinRm6wX/rfF51qmM+I69uaE+jrF+ZAnr+mFbaMjN7XH06T+tXw6YDzYmdUefCyZvjnhZ7YMrInnrn6TN08FzY7Ds9f0won1aqMugZdRG/0bYMPbmun+zy0PUVxKPWr5+D1vm0i9n93X7Cb5fOB5+Pru0NFCMNbR5uevyLwvaamEo1Vh//80EUh243rRbbCK1hYHTW8mtRuX9DUOJLrq0Ghc5ba5dXGy9cFWzrtG9cJCcSZ5TsXvS+7OOQYvWab1Z/iG33bhPymX73+LMx46CL8+mhXrH0mqJXbruRd3KiGhO9FbVVaxa+xFt1ZkJIpKTjWocCa2nBDBDW+krO2ZQB7/hNN6lcL/JBrV6lk2A0SrR+2Wo7+YF92Ch2K/zf2cDelaR9Nmj/8zkXrdqmRWxG1o/Slawdbb2wXvdXQvEFkV6KuQKfObTOqrK1wzdknoXNT81I/9avHHschAD1aNcCCoRcb/r/9qXr7/QO2DWpVhssTGSRQuVLw/9i6YU00qBk9bFh7Dq0Dq1U5+v3zHxftibWy2nb4/9W/2bR+NTSua9xl3C4vtDv2q0Ed0fG0oAPKIoq4jzXDWh961xDeaomFkQPOziJU0DiaAtQKmfioJVbMx29DL8YDl9ozjheOYx2KRbXhfAC9iGgdgKs0LZfkYUO3Um21Umx/qjltn/o1lIqmZ6sGmD+ka0g3mJZUhjT731Tv7doEW0b2tNSt8OSVLQz3xSpGWwHoufiupwcr8Eo60S56b8L6dgSPvS1K95OdmPn/aa/5o9ujt370HEq9ajl484Y2GHdbW90WjLZe9nHkPW5sopus1Uk1bRlgj+cFye9Y/J9Eif1klePDJmNGbEcel8J3uwBP9IzeRVi3Wg6qVEpOgK9jHYoBumrDAKYAeBRKGPQSAHf710nRYofaMKqqFVVr4wWhzFK/Ri5mPXwRnroqOANY25UTPkhfr1oOVg3vhvsuboKGtasEHoqPblcUdF/u0xrnNKqF3IrR/60T72yvm969ZfSolHG3RXZBhbeS/D+gJvWroWrYOEWtsDe6aM4nt6LxGEe1nAoh9+x41dFqncQDlwYneOk5nFs75BmWr6Wz2k3yXO8z8bRB91M8PHt1S5yXp/8iYabi097LFifWMGytAsYO6uo2J6FetRycGzZWdXmUsbwTa+bifwPaY7DBeJiWdnl1LFeo4S2MgReeGvMlpXG9qoFWaHjD07+ZRWQYxBDenacXcah3rD/J/5vVC/VN9XS1G887GZ2a2CePbxXHOhQiGg9gMYBwyc2G/jEUAH6R/zMB/APgQWbuAqAI6jopWuxQG0aVOsATe4DOj8R3fBinHVctpM905fDLsWVkT0wa1AETdCr+6rkVIx7uLqfXx5aRPXFd25Mx+Z5OgaZ4v/aNcJoa4TPqRkWWo0n9auioeeBWP305HrikKX4fdjHeutFYeK5Tk7ohkTgAcOcFjSMGqf3n7nr6cZj9aJeQfU2Pr443b2gTqEh7tAp1YP7B4Uub1w9xKC00XVZEwF9PX46alSvi1evOwqRBHVClUgVsGdkTvzx8EfqqYyPaCreypqwHL22qtKR0arrneoc6jGX/vQxt8+pg44geEWMp/sgpLdPuvwCTBkXqh+Wo3YCnahzeLR3y8OWgDtgysmfEbPLw/+/ZjWpF2npNqK21q0ZWZv6K2H+tzY6vhg9ubYvnr2lleL7LWx6Pd/udi6oaB1Utp0Ig2KJR3Sq4oGk9VMjOivjfN6mvTEhsUFO5npPrVEajsJZMtxb6zsr/GwjvRnr8iuaBFoqec8oiYPYjXfC8ej8ubKb8rv32H19D6aoL71L+7K7gRFK/Qz2pVmV0Of04/FfTcr72bOMIs7PUQJKX+rTGkO5n4MWQ6DKFWlWstdCMxkq1+P8XT/eKlKI544TYKs1JhZkd+QfgQgA9AZRo0joBOAbgVACVAOwC8DqAPlCEI9uo+X4D8LZOmQOhOKnFjRo14kylqNjFY37dyD6fLyT984VbeU9RMTMzb9p7mL9YtC3i2M0FR/jtXzbwA58t5TU7izj/wDH+YmEw36r8g7rH+fH5fDxp8XYudnmYmXn97kO8Yc9hU3b7fD5eunV/iN3b9x/lwyVunr5yJ/93yirOP3Asahklbg8v2bqfmZn/2LSPtxUe5d1FxXzde7/xut2HQspeuf0gvzVzPb/y09/8ye9bAulrdhbx1OU7op7naKmb7/p4EQ+bvJJ/Xr2bS93ewL5f1+3lU4ZM4+emreZXf/qbS9zKvThwtJTX7CyKKGvrvqP8wvS1PGVZPk9Zlh+x/0iJm8fP38wfLfiH7/nfEv513d6IPNsKj/J1o3/jU4ZM4zG/buRdB4tD9i/6p5ALj5QaXk/B4RK+6+NFIXkWbCzgIyXuwPZPf+3iA0dDy3jmu9WB5+PA0VJelX+QfT4fz1m3l71e5V5v2HOIX52xjuetL+Bil4eLXR7+efXuCHvGz98csHvp1v38+cKtgX1Tl+/gnQeP8YrtB3jo1yt5/e5DfMOY33n7/qO61/NPwREePWcjMyv/K///fcyvG/m7Fcr/9pul+bzvcInhPWFmdnu8fKjYFdj+efVu7vjCLB41az0zMx8r9UQ93ufz8VeLt/M7szfwz6t38/Pfr+EJf2zlX9bu4VOGTOMzn/qRmz0xnf/cXMjfLI383+tR6vbybvV3/PeuQ/zO7A3cf/yf/MXCbezx+mIcnTgAFrNBvU3sYC11IroAwExmztVszwDQEops/VYo4ygLoIhGvsLM04jodwBLmPk+o7Lbtm3LixcvTvYlCIIgZBREtISZdUMwHSu9oqoNXwIgh4jyATwFpStrLhS14WwA8wFUhOJcPAD+RUQ9oTiaiHVSiGgglFYKGjVK/nwCQRCE8kTaxlCIaCYR/aXz518j/kYoUV2rmbkhM/sV3PKZuRkzn4bgWiiLoHSDPQPgAQDNobNOCtsxhiIIgiDokrYWCjObl2cNortiIzN7iMi/Tko2gPGc4nVSBEEQyjuO7fIyILBiIxTncgOAm4D0r5MiCIJQ3nFy2LAjV2wUBEEQ9HFsC4UdumKjIAiCoI9jWyiCIAhC2UIciiAIgmALjp7YmEyIqADKfJV4qAdgn43mlAXkmssHcs3lg0Su+RRm1p13UW4dSiIQ0WKjmaKZilxz+UCuuXyQrGuWLi9BEATBFsShCIIgCLYgDiU+xqbbgDQg11w+kGsuHyTlmmUMRRAEQbAFaaEIgiAItiAOxSJE1N2/YmRK1q5PIkQ0noj2EtFfmrQ6RPQzEW1QP2ur6UREb6nXvZKIztEcc5uafwMR3ZaOazEDEZ1MRLOJaA0RrSaiB9T0TL7mXCJaSEQr1Gt+Wk1vTER/qtf2BRFVUtNz1O2N6v48TVnD1PR1RHR5mi7JNESUTUTLiGiaup3R10xEW4hoFREtJ6LFalpqn22jlbfkT3cVyWwAmxBcMXIFgBbptiuB67kQwDkA/tKkvQRgqPp9KIAX1e9XAPgBAAE4H8CfanodAJvVz9rq99rpvjaD620A4Bz1e3UA6wG0yPBrJgDV1O8VAfypXsuXAG5Q00cDuFv9fg+A0er3GwB8oX5voT7vOQAaq7+D7HRfX4xr/z8AEwFMU7cz+poBbAFQLywtpc+2tFCscR6Ajcy8mZldUFaLjFi7vqzAzHMB7A9LvhrAx+r3jwH01qR/wgp/AKhFRA0AXA7gZ2bez8wHAPwMoHvSjY8DZt7FzEvV74ehCIyehMy+ZmbmI+pmRfWPAVwMYJKaHn7N/nsxCcAlRERq+ufMXMrM/wDYCOX34EiIqCGUJcQ/ULcJGX7NBqT02RaHYo2TAGzXbOeraZnE8cy8S/2+G8Dx6nejay+T90Tt1jgbyht7Rl+z2vWzHMBeKBXEJgAHWVHvBkLtD1ybur8IQF2UsWsG8AaAxwD41O26yPxrZgAziGgJKavTAil+th2rNiykH2ZmIsq4MEAiqgbgawAPMvMh5WVUIROvmZm9ANoQUS0A3wA4I70WJRciuhLAXmZeQkRd0mxOKrmAmXcQUX0APxPR39qdqXi2pYViDd0VI9NkS7LYozZ9oX7uVdONrr1M3RMiqgjFmUxg5slqckZfsx9mPghgNoAOULo4/C+UWvsD16burwmgEGXrmjsB6EVEW6B0S18M4E1k9jWDmXeon3uhvDichxQ/2+JQrBFYMVKNELkBOmvXl3GmAvBHdtwG4FtN+q1qdMj5AIrUpvRPALoRUW01gqSbmuY41H7xcQDWMvNrml2ZfM3HqS0TEFFlAJdBGTuaDaCPmi38mv33og+AX1gZrZ0K4AY1IqoxgKYAFqbkIizCzMOYuSEz50H5jf7CzP2QwddMRFWJqLr/O5Rn8i+k+tlOd2RCWfuDEh2xHko/9BPptifBa/kMwC4Abih9pQOg9B3PArABwEwAddS8BOAd9bpXAWirKecOKAOWGwHcnu7rinK9F0DpZ14JYLn6d0WGX3NrAMvUa/4LwJNq+qlQKseNAL4CkKOm56rbG9X9p2rKekK9F+sA9Ej3tZm8/i4IRnll7DWr17ZC/Vvtr5tS/WzLTHlBEATBFqTLSxAEQbAFcSiCIAiCLYhDEQRBEGxBHIogCIJgC+JQBEEQBFsQhyIIcUJEv6mfeUR0k81lP653LkFwMhI2LAgJosp7PMLMV1o4pgIHdaX09h9h5mo2mCcIKUNaKIIQJ0TkV/EdCaCzug7FQ6oY48tEtEhda+Lfav4uRDSPiKYCWKOmTVHF/Fb7Bf2IaCSAymp5E7TnUmc2v0xEf5Gy9kVfTdlziGgSEf1NRBNUZQAQ0UhS1oBZSUSvpPIeCeULEYcUhMQZCk0LRXUMRczcjohyACwgohlq3nMAnMmKHDoA3MHM+1VZlEVE9DUzDyWi+5i5jc65rgXQBsBZAOqpx8xV950NoCWAnQAWAOhERGsBXAPgDGZmvwyLICQDaaEIgv10g6KTtByKPH5dKDpQALBQ40wAYDARrQDwBxRRvqaIzgUAPmNmLzPvAfArgHaasvOZ2QdFViYPihR7CYBxRHQtgGMJXpsgGCIORRDshwDcz8xt1L/GzOxvoRwNZFLGXi4F0IGZz4KiuZWbwHlLNd+9APzjNOdBWTjqSgA/JlC+IERFHIogJM5hKEsK+/kJwN2qVD6IqJmqABtOTQAHmPkYEZ0BZSlWP27/8WHMA9BXHac5DsoyzoYKuOraLzWZeTqAh6B0lQlCUpAxFEFInJUAvGrX1UdQ1t7IA7BUHRgvQHDpVS0/AhikjnOsg9Lt5WcsgJVEtJQV6XU/30BZz2QFFOXkx5h5t+qQ9KgO4FsiyoXScvq/uK5QEEwgYcOCIAiCLUiXlyAIgmAL4lAEQRAEWxCHIgiCINiCOBRBEATBFsShCIIgCLYgDkUQBEGwBXEogiAIgi2IQxEEQRBs4f8B8jLg75SkQOIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# s1 = np.loadtxt('values_non_stiff.txt', comments = \"#\", delimiter = \" \", unpack = False)\n",
    "# s2 = np.loadtxt('values_stiff.txt', comments = \"#\", delimiter = \" \", unpack = False)\n",
    "\n",
    "# #plot norm_p_k_sq\n",
    "# fig,ax = plt.subplots()\n",
    "# plt.semilogy(s1[:,1], label = 'Non-stiff')\n",
    "# plt.semilogy(s2[:,1], label = 'Stiff')\n",
    "# plt.yscale('symlog')\n",
    "# plt.xlabel('iterations')\n",
    "# plt.ylabel('$||p_k||^2_2$')\n",
    "# plt.legend()\n",
    "# plt.show()\n",
    "\n",
    "# # fig.savefig('norm_p_k_sq_compare.png', dpi = 500, bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAEGCAYAAABYV4NmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABHOklEQVR4nO2dd5gVRdaH33NnhhlymgEkowKSBHRMmFAxIWJixRUz6prXsKKsrqKuiuEzoOu6KMZF14SKWVEEEygoQVEEAQUl5zzMTH1/dN84fXPfOOd9nnlud3V19emee+t01an6lRhjUBRFURS38WTaAEVRFCU/UQejKIqipAR1MIqiKEpKUAejKIqipAR1MIqiKEpKKMy0AdlEaWmp6dixY6bNUBRFyRlmzpy5xhhT5nRMHUwAHTt2ZMaMGZk2Q1EUJWcQkV/DHdMuMkVRFCUlqINRFEVRUoI6GEVRFCUlqINRFEVRUoI6GEVRFCUlqINRFEVRUoI6GEVRFCUlqINRFGD6orUsXLU502YoSl6hEy0VBRg6dhoAS0afkGFLFCV/0BaMoiiKkhLytgUjIvWBx4AK4FNjzPgMm6QoilKryKkWjIg8JSKrROT7kPTjRGS+iCwUkRvt5FOBV40xFwGD026soigKsHjNVt6buzzTZmSEnHIwwDPAcYEJIlIA/As4HugO/FlEugNtgaV2tqo02qgoAFRVGy56bgYzf12faVOUDDLggSlcOv7bhM//eeVmJs1b6aJF6SOnHIwxZiqwLiR5f2ChMWaRMaYC+B9wErAMy8lAhPsUkYtFZIaIzFi9enUqzFZyiNWbd7pW1opNO/ho3kqueCHxykXJfaqqTVLnH/PgVC58LjdV3nPKwYShDf6WCliOpQ0wAThNRP4NvBXuZGPMWGNMuTGmvKzMcUkDJU3MXrqBFRt3ZNwGt7jk+ZkAiGslusO2ispMm1Br2F5RuztP8sHBhONQoB9wNNAuw7akna07K/n+940A7NiVPV/y6ghvcyf96wuOe3gqYPVbL1y1JaYyKyqr+XT+qrDHjYn8Bhn4fCqrq33bu6qq2VVVTUVltdNpUZlrP3+R8C7m9rfmsf+dk6K+5e6sdOd/+O1v6+l+ywe8PGNp9Mx5xsJVm/ly4ZqEzt1ZWcXLM5ayeceumM9ZtXkH3W55P6HrORHte5yN5MMost8JdiBtgT+w4jJHY7VovhGRicaYeakwYNXmHVRXQ6vGJUmVM33RWr5buoGzD+zAmi07WbRmK5VVhknzVlJS5KF+cSGvf/c7y+23/CuP3JO92zbh8Sm/sHVnJT+t2MyAbi3ZVlHJl7+srVF+y0bFVFRWs35b5B9J47pF/PWoztz+tvW42jerR1W1YY8WDZi7bAMAm3dUUllt6NqyIRu37+KQzqVUG8OEb39n97L6LFq9FYDT9mnLa98uo8AjQZVo5xYNOKlPa+7/8GeGHdCeLi0bArBh2y72ueMj1m2tAOAfg7pTp8CqoO9450cqKqsp9Ai3ntjdV9Y/3vzBt33mAe358IeVrNmykyuO2JN35y5n0RrLlhYNi7nyqM78tHwTm3ZUsl/HphgDt070n3/zGz/w27pt7Koy3PfBfF96h+b1OK5nKzZt38WLXwdXzgN7tWL/js0o8PgdyeotFb7t3zds5/mvlvj25yzbyJ4tGrB0/Tb+O+03APb4+7sADOjWkgbFBRywe3PqFHgoKvRw1Yvf+c5t06QuRQVCzzaNKW1QzO5l9QGY8O3vzLJbX8MP6USH5vWCWk4//LGJST+uZI1t14hX5/DN4nWs3LyT3Uvrs4ddjg8RMIZNOyqZ+vNqPCIUFgiHdS7jk59W0aN1IxrVLaKwQKhfpxBjDGu3VvDr2m3s17Ep23dVcde7PwFwxn7tWL15J1MXrGZXlfWdGXZge+syAZdcvaWCKT+vDmpFXnXknvy8cgvv/7ACgN5tG3Pavm1jahV+vnANM39d77vnULrt1oiBPVvRpF6RL+2PjTv4bMFqju+5G2/N/gOA08vb+X4LI16dw+0n9QDAW98bYzDAc1/9igDn9utItTHc9lZwdfPcV0vYXlGFAUoKPUHfl3D8vNL/ktVp5Lu+7f07NmNQ790QYMGqLdQvLqR14xIQQbD+fYLw27pt/LRiE11bNWTlxh28MeuPoPL7dy1j7zaNKW1YzNkHdoj4MpQIkmteUUQ6Am8bY3ra+4XAz8BRWM7mG+Ae4FxjzLF2npEAxpi7Hcq7GLgYoH379vv++mvYxdnCMvj/3qNyxxbevelPidwSAJN/WsX5z3yT8PmKoijxcLLncx6q8xivVR3CQ5WnMeXO8/HE4PRCEZGZxphyx2O55GBE5EWgP1AKrARuNcaME5GBwENAAfAUMB8YhPWCVAHsAqqNMVdEKr+8vNzEu2SyMQa5rYm1M2pjXOcG0vHGdxI+NxU0q1/H14qIhcO7lDHlZ2uQRJsmdfl9w3YA7huyN4vWbGXCt8tYuckKoN9w3F78tm5rUEtg5s0DKCr08N9pv3Lv+/6WwzHdW3LXqb3YtrOKc56azpK12wD45qYBgPWmtnjNVq7+3ywO2bOUa47uwqyl6yn0eOjZpjEH3v2xr6y9WjVk3Hn7cc646fyyeivf3DQAj8C+/5zky/PdP46mTqGHogIPXW5+r8Z9vnZpP07795dBaZ+NOIK6dQpq5B07dRFjpy5i/07NeGzYPoD11nvja3M4rmcrrn91DgC3ntidXm0aU+ARlm/cQc/WjSkqFHZVGiqqqtlZWcW7c5fTpWVD+rZrysrNO5gyfzUej3DOQR0QYPnGHQx65HMApl5/BPWKg+0pD7hHL1Ou78/h930KwIybB/jSA6sEg6G6Go5/eCrrt+3ihQsPoNtujagyBgEKCzxUVlXjEettecGqLfTvWobgf67vX30oFZXVbN5RSWmDYgo8QtN6RYTWPGu3VLBs/Taa1CuiWf1iJs76g2N6tKRFw2Ke/XIJuzXwcGSPNhQU1HzWoWzYtosBD0wBYNSJ3flt3XbmLd/ItEXWGKFXLjmIPcsaUOVQ/1Ubg0eEY/45gRaygRduHs6aLTspLvSwq6qaJvXq+FpQ3jd+AbbsrGT1+g30mnQW204axw9bG7Jy0w62V1TTqbQ+e7ZoQN06BRR6hC07neNgdaePQSq3s+3gG3xpu6qqOejuTwCYNvIoDIaKymrqFxdSsHIuTZ8/ii0H/o0G0+5n1TV/gBRg7P/j4jVbKS7yUNagmLp1Crj3/Z94a8ZCPioeQVvxdxdWF9VH/v57Qi2YSA4mZ7rIROQprFbKKmPMbgHpxwEPYsWTnjDGjBaRIUBH4P+MMW+JyDQgJcMwkmlSTlu0ljPGTuMsu7sgHVx1VGfGfLygRvriuwciIj5H17pJCeu2VjDxioPZu20Tbnnze577Knzr7pnz96PbLe+zY1c1T5+/H8c8aMVSdi+rz5/K23HDcXv5yh5+SCfqFHqCHEzzBsUAXNZ/T5+DGXv2vhzaucyqvBvAp9cf4SujrGGx79zSBsV8ceORvv3jGvu+HpzYuzVvzf6Dh8/ow0l92gDw8XX9He/hw2sOo2n9OjXS7x2yN/27llGnwEOTesHH7z61F+2a1XMsr2ebxtYzKK1PaQO/vePO2w+A75ZuoEXDYs4/uJPvWF/HkqBH68a+7fbN67Ffx2ZBx5sHlN++eU17/j1sH99Q2Q+vOYzZSzfQobm/WyzQPifaNK3L+m27aFhSFPyMdm2HunUBaFq/Dr3bNfEdmjbyKObOX8heO+ZCx4PDF758DlRsobRDP7q2auhL/uuAzr7tawd0htubwoaLYeB9EW0FKC70h5fPC3i+v63dRrtmdSP/bp8cAPVK+aj4c5rLZvillGZ7R++daPrfo2m3fBYAjR/vQ7+/L4c6pY55S4ocnOS4Y2DpdADqffV/8Nc50LRDUJYa3fDfTgagwbT7AWix5G3oPTRs/nuH9ObewrEwKzgW5dm11Xpbc5lcCvI/Q+xzYH4HWuMfXVZip2UVj3xiVfTefvh0cO3RXRzTvT+4qwd05slz/C8jYr+r7dwVOdAtIrRralVsgT9uJ2JthR/To1WNlsHXfz8qyJlEI5YWujf+0LJh8I/x7AM7cECnZpxe3o4WDUtqOJdRJ3bnz/uHfzk4vmcrLjl8D0Ye383x+F2n9OLqAc7/D7cpDXDIXVo25E/lLox7WfoN3NkKFnzkeLhV4xKO/vAoeGYgTL4btoSZBvCfQ+Hp4yNfq9p+4/96bEymecJUlu2b14vsXOa/B8u+gZ/fs5wLwIQLYcemyBes3Am2c/Ex/d8x2QrAzi0+5+Lj4b1hg0PdsGwmjGoM790In/wz+FjFZqjYFvlaiz6N3a4kyRkHE+ccmG+AJsC+IlIH6ABMdCq3Ns6DefWSg7j+2K4A7Na4hIfP6OM7dvWALgzo3tL3AzV2R0aHUst5/Hf4Abx2aT8+G3EES0afQJsmdX3njr/wAP5z9r4UFfi/Vk71eyzBzXC0aFQSdM1YiVSpPD/8AO46pReNA4K9AHec3JOX/nJQjfznHGS9VUZzXUUFHm48fq8a5SbF1pqDNxxZvwTWLfLthrZ4kmbDUnjlXGs7tML6fSZsXw+bV0KlPex8ymh449Ka5YR+Qdb+AgtqduexM0oFH4L3Oxb0b596P6yY62yDt1J+8QznAn+b5pxeudOy+ZXzax77+Hbr/xALYw93Tn/xzJpp4462Pp0c2DvXwV27Wc8+HJuWOaenIFySMw4mDI5zYIwxlcBfgAeA1cBHxpgfHM7P6DyYTIW/yjs2o3fbJgB0Kq3v6zoK5JE/9+XsAzv4umb+ctge/O/iAzmkcyn7dmjq6xZ64/KDedmuhFs0KuHYHq2iXj+0sm9YkrqeWu8jjuTSWjepy5kHOLREjIG72sKMp4KSMzavZenXcN/u8P0Ef1p1Nay0Riu9cslB3DbYGuHEw71hTJgOt52brRbF0wMTt+WFobDJ7hQI/SI/cSQ8dxLsCnmTDt0PPbdiGzyyD4w/LTjPltXw7In+/VGNrUo9AiJQRCWLi8+E6WPhy0fhkzvg8UOCy5l6H8x8xqqUIzkDJ9sB3r7Gsnl+mBhqZYSJu4unwiZ7VNfahc55tliOon5gS15iqLYXT42eJ5Rq96czZE0MRkQmAU61003GmDfjLc8Y8zrwetKGpZBsHl/RoXl97ji5p2+/wCMcuHvzGvnKGhYHxUNCCfQl484td5x/8enf+idla0RMTTtipqrC6nJ4dwSUX1DjcEodzSg75hI4cGT5bOtzyWfQ81Rr+6tH4KNb4MJP2K/jvrG1VB7sCTs2ANCKM1hBzf9rVLaFaUl55xEtn13zoTtVjCagUnvprJrHX/wzzH+3ZvqvX0DzPWqmb7Tezj0NWtMA2yl8ejdsD+n88Nr5yT9hj6Os7TU1Y5M+XjkXejgM4onW3RTOGeza7neakQYH2edPHXEEm3ZUWk64Ooa5OJ/cAaWdrZbR+e9Bh37Rz/FEHzwRL1nTgjHGDDDG9HT4i+RcnObAZF2sJRwmaidL6klBXC+IQCd6VLeW/Odsf3zn9cv68dDQPkEBatevn8wzNnYlFFJJnLavpUDUv2uLxMv2MucVqNgaW16vHd6HOv89y7lAUHdYEIGtHS+2cwG4ovCNmsdXfB895rBlRcBO4LCzwLfgWBxMQGzvl49rHndyLuHKAniwBzzYg6LKbTw8tHdN+7xUBYyQ9JYVa3dWINHe+r1lz3gaxp/uT98UMB8l0rO2z2/eoJhOpfXhzctjs2vDr/DNE9b2/JqjIZ2vVbuD/E58A3QWkU52rOUMwsRaspFsbsGkg77tm3Jy35rdc6lAnNobs1+C926ome7FW3lUBXdz7N22CUtuOYiOW2YF568KGXq6fUNko74bbwWQQ234bbpzfm8F4K2UA9/4pz/u/IV69XxY8kVYE44q+C44oboaHj8YRreL3L0TyM6AlUADK9zQCstbqS7+zH/PCx3iLbHw3XhYPT/88Yf35rAv7BjR9hCx0Wn/hg/+7t/3Ps93/xb5mh/+w2pZVtktiCeODHG0Dsx70zrn7athwQfwwU3WfmBwfnSEARebgydGsnhK5OsF8t1/rU/v/e3a4W8Zp4mccTD2HJivgK4iskxEhtuxliuAD4AfgZfDxVqykVj9y8WH7Z46G/LRyc1/D9YtBqLc3+sXWxUzwMxnreD0ht/g7nZW5VUd4jC2rYMttiTN+CHW6KiqSqu7Y1RjuKO5v8Xw0tlwTwd/t0vFVrinY3AA+83LrM/NIVLugW/S3htYMRc+vsNOsysMT0AP9+8zYMnnzvf5zMCwzm43Wcedp/i7QoO6X7zPJpSqkC6aigBJn2+f82+Htp622UNjnx3kL3viVc7XiMZvX8K/9g9/fNtaWPOz87H3b4QZ4/z7Ti0nJ74cY33eUQrv/M36vkTj49uC97961Pr8waFlGY6lX/tbOeG6JiPx1aOwaXmNWGI6yBkHY4z5szFmN2NMkTGmrTFmnJ3+rjGmizFmD2PMnZm2MxUUJjHqKhd5/bJ+3H1qL6tyjTQaJhwvngFj+sCzg7lzsTUnIOhl+tcvaw7/fOsq6410/vvWiKWvxwZ33wDc2wnu7wyLpvgrl8rtMGmUP89PdrD3R7sh7XUWd7W23qS9AextoQMiAwgs77vnrc/HD/HHEbxp3hFaXryB6FU/1Szzng4102yGHRBwLPC5eLvfAvBUbLIq2EAatbHuZ/Fn8OUjAfdxa3C+0JYE+J1OKNXVzumhBAb7H43gcNzG2/2UDsYdbbVyKrZBkwTnzD2wF8x6wV27YiBnHExOEOuPwkuMrYdwY/rdIBVFt4gQ9I+Fvu2bWvNLZjwF/9fFigmE8vMHVsvBy69fwv1dg/uzF0+hWdVqPFTT6een/ENRnz4eHtrb+eL17CD53FfDj8SZ+Yx/++62/tFUENyqAPhmHI48eZR/e+Ekv8MxJrhbZNk3UBmjooK3v3+lw/OyaUSEeM+KufCo44Rs2tujBtt9fUfNgyWN4aFeVsukKoqty+f4tzdEENxc+BHc0yn8cS87N1v/+1GNYU2ELrN84N2/Oc+LiZWVDkO0U4w6GBdYX6e1tRH6xhuFHTEq5Do1YO7/U++aiQmQii6ywgIPNw20Jhe2TmDOio8ln1mfoRXH8tnwwunw7vVWv/7MZ6zuoy0rYMWcGsWc4JlGt7n3hkxKC7jxrQFv0XbXGnUawOSABnHg/JPAmAPAjwGrQYQ6mJ/fc47zhAbl7+0EH94Mq34MTq+uDj9ENpSv/mV9Tv9P2CxP1rm/ZqJ3kMHku2oe27YOqqt5oNtC3un3M41+eqlmnsl3+rvJosUk/nOof/uhnuHzvXB6zZFfTow9PPokzXxhVu6t+p41w5Rzmdmlg+j/x1hij6pYzFkWm3aZ0yTBzi0axHWtmmUmdXpULjy0E0P3b0ejkiQmGXor68Dg+a4d/q6WBR/BH7OsN7PmtqzI8poOppXYFdW0f8HRt9U4HuQgJttOaNMyaNTWnx4YZ/A6Pid+mAAn/ys4LTSW8XWY7pUvH4HuJwenmWr42UHy3am7Y9FkKz6y7GvH4uuyg/09Dm/5ozvA2ROcR2zda7UiSoAezlYrSljUwbiBb3RPaiLmgV1kHoGJVxzi07lKlFQH90UkPudSsdUKRJbuae2vW+QPTFdVWBVnxVYrllBoS7psWeF/Y15rB9M/GFmj6EEFAbOwQ+MHEH60VOCM57evCcgfYVG0XdvgdYcZ64F8+2z4Y6FdTL995Ry7+Ph25/Mfq6k84GVCnVHOB6p3BU9kVBSX0C4yFzC+MfmpqbXr1vH/m64e0CVp55JRdmxyHpc//nR4dF9riO7q+dYs9IW2xtXEKyzH8Ie99HCkCt6B3p4wc0S8xNIVE+tII4DZUYKpkbx7aHfP+sVWN1sooSPPvKwNP1mwmyd9mneKAupg3CF0fkIShApFXnt0l6BRPvHqeO3fyXlmd6q7yMIy4WJrlNf6EGXmX+0htk8dY8mMOPH8Kamxaco9qSk3HKFxFiW7CO2mTBfnvQul6RE/TRd57WBE5GQReUJEXhKRY1J4JevDhX6nDiFS61cd1TlI2jveIcsDe/rVdz4bcURyxsVCxVa4owX8ZPfnb15pTfha8b2lf7XOHlbqbYVM/0/NuRDh3s7zBRPb4I6sZu+h0fPkKoWpU5aISMsecEV+LTqYUzEYe02YQVhrwvQMSD8OeBhrwbEnjTGjAYwxbwBviEhT4H7gwxQZZm/E7mDCrU1f1rA4aJlUsFotFx7SiSc/Xxx3C0ZEGPPnvqzYuD1o3ZKUxWDWLbJmvk++E/YaCP/7c/CENAnRO3pvRIoMUVJKh34w5yUo6war86xFlrHZx/k36znXWjDPEPuaMIHcbOdJCZJAkH9LhfOKdoEMP8Q/D+CKI/fk9PK2zqq/Edi7bWMG927NxYc5CAOmAu84fe98FO/Mdy/et/e8lBCoRXhfFBqkV4E8r/HOo/trzZGQCdEr8SXc3SKnHEyca8IgFvcA7xljvk2dZV4RwthjMNG6uto3q8c/Bvn9ZJN6dbh3SG/q1Ym90Tl31DH0bd/U8VjMMZjlc/zO4vsJthZTBOfojWds9AaUw1xo/RKNReQyvoEt+agykcTLT59hiZ9bt4n1mehs/VD6XelOOUmQUw4mDI5rwtjbVwIDgCEiconTya4sOOb7jcX+xXQUX3SZhhGGCXuHEIfGfIJYs8CaGDe6nSU/8qq9qNKqef48z50ED3SH+7zzUGb7j025t6ZYn5cXh8JjB8ZyG0o2Eo+0e7FLox6HPO1OOdFItnXdLcEh395n6toInMw7/6xyMCIySUS+d/gLM6woMsaYMcaYfY0xlxhjHJX73FlwLERGPQnaNKlL/65lPDi0T9JlRaJX28Y8eU45t54YMH1u5xZr7RPvzO7A7q3AGfIf327Non/rams9jE2/w9ZVlvR8IJPvrCkYqeQH9e3fSiyVYYu93Lnm7v3jP6fv2e5cO1bqNYeh/4Ujboqe9+JPo+fpnlDVZ1HfYc5XIAf/1b9dPjzx60Qgq4L8xpgBCZyW+TVhvMsLm+qY3xnCrVNS4PHwzPnxifaNO7ecpvXrcOpjX8Z13oDuLYMTpj0GX//H6lc/7HqCWmSbAyRAvPNTQplwYVzXV/KAWFZXdOtNOpE3+4Ov9ouDRuO0cdBrCLwWw/e48zGWuGdlgB7eiWP8o+saRl/ZldZhVhwN5OCrLa23QJXqWGnUOvLx/iPhi4fBUwSDHoi//BjIqhZMgmR+TRivgwkzMiwe9iirH/c5R3VryT52rOXcg8Kr5kbH/gF7RSQDY0of/SOJcpWMUFAn/LH+fw9/LBrdBkOnw61VPgc/Gj1/NMcwYrF/O1Klm0gPQaRrh+rG9RoS/jqDHgzer66qWfa+50JRiffCwceGvQrNIgy0qRtmJdJmu1tOJpWkcFJcTjmYbF0Txivlsml7jKq3hP+tXHBwDAqyAQSOKlsy+gRuOymCgGAktq2zlt8F+Oz/4LZmls6Xkrt4JXWc2P+ixMvd9zwoKLQq3caxLBgXpQIraRIw4ilM3h4uTrItbmR9tgqjqO1E6JLZ1ZXQ7oDw+UMr7c5HRy6/rvNgHOo2cV4a2g28LyApdGA55WCydU2YggLrTeiS/8awAFEUPHHMc1ky+gTuOqVX0tdk+3pL1HBHgPimqdJWSzbSL54FuqJ8lxpG6UJxi1jekA9wHIPjp+sJ7l27pR13HHBrzWMAzeyXvJIm4cs11VasJex1461ak+j9aNgaRsUmnBuEp8A678gY4kUJklMOJlvxOoWFK6OsYx5AVs0Cmftqpi3IfRIJQNdPYFBJtIo4EKHmxNZAYgkyu0GrKC9BIv4m/dYER3KGLzx8mifMKEuvY4k05Li6CoojKZoHXPf4+yLks8nTeWHqYFzA47Eeo2SX21DSyRE3J3ZeuL53NxBPzTiD75gQ9jXnaIdFxWLh7Dcc0l6PXp6If5TixgiLkEXj3Lfgr7OD02KNLxwWp6KEd8LwWWGWPg5swUSywfeSkea6o2WCXelxog7GBTwJqCmbbHpjySZbcpVGu9VM+1MEWX5wP2jtxdf1FSFvUf3w1z84nm64APYI0bo7+w3Y40gorAOXfBH53BIX5sp0OgyadgxOEw/8Y401YsqJ40ZD+4PCdBOFPJ9me1ijx8BqwUQiVgcz3Favive70Pcs/3aDFuHztd7HOd0bh0ox6mBcwFPgbcHEzpadaZ4fUlmR3HKrSmTqOHSXOA1V3S8wuJ6AgwmtiJy6n4obWp+HXutcxlkTrEo/0bfmSBXmyIA1dDod7t9uFeWNufvJVnwpcESZKwgUFEH/GwPSAu77wEvhAocF3Zy46lt/OdEESzsdFmxDWPPsLsyCKGsnnfdO8L53gEH3k+DP/wt/XugAgbNei3wdl8mqeTC5i/UF8hC7VMznC9ZEz+Qmb19tLbl6xUz48mFrzZXt66H3GVCnYXptyUdiDeoG9tu7sLyDY+XV/kC4wl7V8mOH7imvrZHemsWTmH3FAd+liEOEi6yFzrwUFMIxCXbNpQwH+70vEvUjtBoAGrasmeb0PJq0h0P/Bn3OjFxex0PgsmmWUsbmFdYEUqcWWyh9z4K5AROgI40sTAF57WBEpD4wBRhljHk7hdexPpMs583LD07eGOD1y/pRvzjkX7vAboo/um9w+se3xxaEVCITa19/oCNq1QtWzHXO17B1eJmdaESbRZ7ovIcDLoXp/4bG7aLnjXqdTHbLxj4dugZlXeHkx6HLsbFfzisB4+TQReCoGEdrtuhm/XkJ51yG/hfm2VMBd+8PN62AO2OY+JkCcqaLTESeEpFVIvJ9SPpxIjJfRBaKyI0hp90AvJwG46yPeGIwDmm92zVxxZy+7ZrQ5Y83LWHKB3rAf4fUXIo3kPeud+W6KWWfczJ37Rtj6VqModK66JPg/eZ7Ouc79i44L8b3odCRaKM2Or89B2Hb2qh1hOC2w/0ce5el9FvaOTbbIrH/xXGeYFyMG0T5nXa1VxUNt+ZNnz9DvTgGZ8Q9ZDlJup0Ipz3h3y+qC39baHc/plefLGccDHFK9YvI0cA8IEQv3n2M/Rg9kvhb2d2nujCfBaz15e/bA9683NrftMySdgmc45KLlLmkZxUJp0B0j1NjC0A7VSKBb6ylXaBNSOsRcX6rPehyq+/cqczAVsGxd8OpT9TMEy5/aJqIFdzuOtAhj8O1PR5omoxSRADH3hW/anBBQKv8wk/C50uW5ntYjrp1H7j6e7j2p+TKE7dFLBOgQVl8TtElcsbBxCvVD/QHDgTOBC4ScX6NcENNubAg/lFkgVnbNavLn/d3SaL73eth21p3ysomUv0WGE5UsP1BNdNGOkjdRa08JOQzhKtm1Uy7YQl0OS44rchWv+71JzjoMqjfPPJlHeMsITYcf69DlhRXhiJw4cfW0OJ48M03SlMXW5N2ziMEQ9k9wmqx3u9uKoekZyk542DCEFaq3xhzkzHmauAF4AljnCOWbqgp92rbBEh8HszEyw9J6DxH/kjhsjcZJaTCC9WGAkvCJFFOfSI+CfoaRKmQ2zvIigRW4k6tpJLG/kl/B10Bgx6ypEMu/zo2DbBwlHUNb0c6adAiZLRVDJz5Mly/KLeG1nsHdgx9Hgben1lb0kzWOBi3pfq9GGOeSWWAH8BjV0zx/EwD1ZSb1o8gShgvW9M8Oi0T/GNNTW2oRm2g46GJl1lYbHXDHTbCCuLGS6QWVnEjf8USWJnXiUHY1Ju/ZQ8ot9fjKesaIKoYBa/G1z8Cvhc15k1ImG2XiTScNlYKi6O32sJxyedw5be4e48xOLq9BlmfDVtZGnAXfGh1vdUCsmYUWc5K9QOJDFNOGekOKKaLwPtymjNw0WRY8pl/v7BusJR6LGV7YxKLp9bMc9j1MPU+f74aZUjN/F5adLcqxkA8hXD4DTDzmci2JfumfuLD1vDfSPMsAm33xWdS8D3yBs9dIcbnEnhvvjlDaWr93LjUEpQM/W44tWbzlFyvjTIv1Q8Bo8hiJ6l64+kT4KWzrcmTU+6z5PU/ugUWTYmsPZXLROvGCR05dd2PcN382MoOmvyI8/yPI2/2xz8gYFSOz8Ca+R2x8x02omYL5tofrXlKblJQGENwN8B27/yOQ69z145kkIKaXWmRpO/TSoTvZUmj2FuaeUrOOJhsleq3rQPgRM9X6bncr5/DjxPhn2Uw+Z/WokFfPAzPDbZG+tRWAp1Q3abhF30KDbaGOq9w3v/4e61JqYUlNUflOL7xx/kW0ag1lIYMXU53fGT4B9bnYVkwdP2yadYiXreuq/m/rN/cGumVJsmT8ORQLCiI9NidNV1k0TDG/DlM+rvAu2k2Jxi7Eri26FVgnLtlV1fBM4Pg8BE1tZ68rJrn316/xN3rZ4K6zWB76IBBBzoeGtwtFis3LLbmCPkIrcTD/Pj2Odv6cyLQEZzzZvhjoZgoedIRzPZeu34L/+S9VDm2wY+EX/sklNCJhZGIR2W6NpPmF5Za/LrrIgn802KuNrauht++hAkRJqbNezP8sVwhaPGmMDOeQ6mh3uuQxytOGA+JdDMG2heTdH+M34AS+w09NIbjRCJrggBJB73PfDlY42qfc8Pn3eccayKgW5w61loF89i73CszLjI4tyUHyJkWTHaTyi+Zt+xcbYq7hcMzLgj5+rr1dpbMaLTARbxa97Uc53Gj/WleG2NtmRx1q9V11v3kxG3ysu/5zqKThfYoxtIuNfP3PA2eHRS53FDZlMFjrL900PV4lwcPxEsKf5fRdMZyAHUwbpCAKGDMPR/xVkjZTmkXS21gw6/B6QdeCkunW9vhNJsSwRu0PvctePZEKIihJeDxWIH/b6LMkg9l6PjgNeWL6vrl2H2Eu48w6cUN4JBr4rMjHCc+5Jxet6mlsNwmRNr9xIcy87078mZ3gvgdD4UGadLgcrvr6S9TY9d8iwevIsZBl7tftgPqYNyg2i+9b4zxiV+6yrY8md9SvwWc8wa8eAYsnARDnrImFO5xVJQTY3mmdp7ALpjj74G25VZlc8OvzpMpkxFlvGKGf1GvblHe9OMpN93sGeb5Z2ISplsDDGLVc3MDtx3xbr3dLc9LvWZJdKXGT97GYETEIyJ3isgjIhKhU9gFoi0+5IBJpIKpqoSVGRgkB/G/CR4eqjtq4/FYczIGPwrlw6HbYNhzQPSKLJaKzivCGLgOSXEDa4KiiDULvthpaYIkKtHSzv413GMhk3pUtYlYlqDQ/0XKyRkHk4Ca8klYEy93YUnIpI6gFoxLZS761Brp9OUj/rQPb4J/93PpAnHSN8L65E4cMRKKHeRPTv639dloNxj0QPSFlnzEUBm07GHNfdnvwpjNTDstewR/ZltLJh8440W4NMoKmuBuq0OdlSM542CIU00Z6Ap8aYy5Frg0pZZFW93O6ZRo3+3nbIWcLwOCpdMTkDBJNYV1rcWjAvFOihv5W3BzvHE7aNw2hkKT+OE3bBX/jz2dlUO3E+Hyb/zimkV1k7dBPNHXgKlN7DXQPdXnWMmXGKnL5EwMxhgzVUQ6hiT71JQBRMSrpjwPq9XiXQQlfg8QDwGB41r3NTt+NEy9HzbamqMXfhIc6E6Wph2D5/YcfoN7ZWeKsoDRWue9Y02aTWZN+lvXJ2+ToqSAXGrBOBFWTRmYABwrIo8ADuJSFm7I9dN2v8TOyyUCWynNdvd/7hUS2PYUJK8m4PXS1/4YPGR41EY44u/JlZ1tlHbOLlkWJTGyoYvMaWmJDJM1LRgRmQQ4RZJvMsbEPZPQGLMNGB5DvrHAWIDy8vLEGiBlXVjVYC9+2ehhP2OIJV4Q9kLb1wdrXmULB18FU+z5HJd+aa2QGfrW3WrvgNiCC2Tjc1Dyh2xwCm5y9uuwY1OmrQgiaxxMbqspQ0VBPTyyLeb8zW2J/q4tQ0a73NMR2mcokB/IaePgNds/X/5NsDBjUV1/7ACs2MrGpTDslTiC9pFwcr8RfH/oolxukG+Vj1ITN+Imbfe3VubMhhhY6O8yC8gaB5MgPjVlLMdyBtYKlmnHu2xyrF/Zlo0sldUbjg9Y/Okpu6L87UsXLUuQorrWBL81C/wxA/E4D/Md+l9YPCW8uKSPGCvtwmLYiVXJR6vo/77ckkRPBnUmSqKUNIKr52baiqwlZ2Iw2a2mDIjEuR6M5YoKAuMVv7msxnxB6CzyCDitkDhgFJwx3r9/0wpLpj6U+s2h56kxXCRG93veO9YbYUnj6G+ZderVlIyJhy7HQ7+/Jn5+baHdgZm2wH30xSLl5EwLJqvVlAGD4MHE3Or25vN9xf/4zn2jwi1sdM5ES9o/2KLo5cUiuOgGZV0t9eh0cKYLqyzmO1fMiKF1qig1yRkHk/WIB4ljkHINlfb3R7puUlh2Pzx6nmwZGadvmZnHq5CgKHGSM11k2Y6vBRPnTBjxtWHSXJGeG6LTFKgFdt47Duu2J0HD3azPqCsrAvVC1lvP1AS25nalmgrBQSU70MmRKUdbMG4hHuKZZplV3+0a4ncuO7tj74JXz49eWQ97DVrs5e61E2X/iyxp+w5ZMKJPUXIUdTAuEX8MxsqYuR6gCIa6bVSsQ5c7O4xUz9QDElHnku9o92vK0S4ytxDLwcSKLwYTcH5G6HCIQ2IW/fCyqqmn5AVl9tSAkiYZNaM2kLctGBFpD4wB1gE/G2NGRzklKQzxBfl9pKsuH/k7vHqBJY0fFZcr9Y6HWN1jbq3zoSjJcNw90ONUaNk9el4lKXKmBZOAXH8v4FVjzAWAi+qLzhjxxNeCqZE1xZ6mqC4MexkOuDjksgHXbRdmWHOy1G0K13wPrfvEf652YyhuU1QS20hKJWlyxsEQv1z/NGC4iHwCvJ8OAyWeGIztjHyjyLanWhE3hoq69xnWZ9M4FtBSFEUJQ844GGPMVKzurkB8cv3GmArAK9cPcD5wqzHmSOCEcOW6oqYMVBpJqIvM94K+K3Yds4SIpSWw7/lwyzprMTBFUZQkyRkHE4ZIcv3vA1eJyOPAknAFGGPGGmPKjTHlZWVlCRvy86qteDD8vHJzbCeE+qL1ixO+dkzE4mBEnNesz0f+MhWGjo+eT1GUhMmaIH8K5Pq/B4YkbVjMWFpk67dVOB79be02mjeoQ/1i65HXGEWWLKeMtZZZnv2CWyXmN7v1tv4URUkZWeNgcl2uvzqKqzjsvsns074Jp+zTlvIOTf1aZG4FsXsPhb1OiN3B6PBfRVFSTNY4mATJGrn+8o7N2PnrIl8LxYlvf9vAt79tAOD2k6yFuXSQlKIo+UrOxGCyXa6/sKAQASoqqznp0c+ZvmhtxPy3vJmZVQVyjp6nWZ/ZsAiboihxkTMtmGyX68djxWAWr9nK7GUb+fvrc/n4uv5RT3O3AZOH3V6793fQSlMUJRfImRZMtiN48IjxaYzFfJ6bHkbjKoqiZBHqYNxCrEdZVR1vJS/waxYskawoiuIy6mDcwuPBQzW3vT0PiHN02NT7k7v2JV8kcJK2dhRFSS05E4PJdgTikuv3nedGF1mrntZnSaOax4Z/BPPfc+EiiqIo8ZE3LRgR2V1ExonIq/Z+fRF5VkSeEJFhqTegIDGpGCCu1sQFH8aWr04D67Pd/jDg1jitUhRFSZ6sdTDxqifbemTDA7KeiqWmfBEwOOUGe4LVlGNtmIhIfMH5NvvGlu/iKbGXqSiKkgKy1sEQv3pyKG3x65RVpchGv20Ei13G6jIKt66ERZNjv1BBIdy4FK6YGTlf6Z6xl6koipICsjYGY4yZKiIdQ5J96skAIuJVT57nUMQyLCczi3Q4Ugm/4NiCCAKYTX5NYCWBkkbW34jFUJ2k71QpAUVRUkQ2t2CcCKueLCLNbeXkviIyEpgAnCYi/wbeClegW3L9iIcCqv27AYeufmlW+NPiqeC7nxy8X68ZNEhQAbqxLeHWSRdeUhQlNWSsBZMC9eS1wCUhyefHcN5YYCxAeXl54mN3CwopDOiJW7BqC8YYRIQf/tgU9rTtu2K85OVfu7sQWPM94Jp50FDXflEUJTUk5WBEpI690Ffc5Lp6cigeU0kD2YEVfbFaJVMXrOHwLpFbGFXV1RGP+2jUGgrrJGdkKI3bRM+jKIqSIMl2kd3m3RCRg5MsKxZ86skiUgdLPXliGq4blabfPwNAf89sX9qb30X3fdVGYyCKouQnyTqYD+wYxjCskV2uke3qyeHoLMt82xNicTDhxpuVD4cGLd0yS1EUJe0k3EUmIuOAjUBfYJoxZqRrVpED6slhuKnoBZ6oGuTb3xBmhUsvxmnGzBkvWIuH/fS2P624YWwGHDYi9ryKoigpJGEHY4wZLiJ1gX2A/UTkP8aYv7hnWn5w7lNfJ1/IwX+NPe+RNyV/PUVRFBeIq4tMRI4Xken2TPqXgd7GmC+MMQ/VdueytZ3zcN95y8OPILOIEIOp19z6POiKxIxSFEXJIPG2YB4DzsKa2LgvcL+I/MsY86LrluUa4uyrd1VFHobs2EXmZdir8PP70KBFMpYpiqJkhHgdzCpjjFcbfpKIfAVMB2q9gzFuzlmt29T6bNwG9hseOa+iKEqWEm+tuFhE/mkPEQbYBVS6bFNOYjyJhbPqVKwPThjyNHTQ9ecVRcl94nUw1cApwFIR+RxYCHwqIp1dtyxOHOT6T7al+l8SkWNSff3qwrpxn3OoZw5dv38gOLHrQJcsUhRFySxxORhjzJnGmB5Ae+CvwCisKPUTIvKbm4YlK9dvjHnDluq/BBjqpm1OVHvXX4mDPrIwBZYoiqJkB1EdjIhcFJpmjNlpjJlpjHkKGGGM6W+Mae+ybc+QnFy/l5vtc1LKul7WY/qsqmfUvJ1K64c/qOrGiqLkCbG0YPpGOT7Ku+GmXIwxZiqwLiTZJ9dva6B55fprIBb3AO8ZY74Ndx231JQbt+vGRlOPX0xrjvdMpyDCEjST/9YfCDeCTB2Moij5QSwO5jg7lnGJiOwnIsUhx1MmF+NAPHL9VwIDgCEiEqqy7MMYM9YYU26MKS8rS1D6HihtUEw1Ho4r+IZ/13mYywriFoRWFEXJK2IZ+vQB8HeseS9HAlcDwyA5uZg0yfWPibecZDBAKRsB2E1CG18xol1kiqLkCbE4mOnGmPXAJPvPRzJyMfkm1w9Wl1e4VS29TLzC34uoXWSKouQzUR2MMeYZ77aILADmArOxliKebYxZAnxh/6Uan1w/lmM5AzgzDdeNCcvBhGfJ6BPSZouiKEqmiXcezH+AFcBarHjL9yIyV0RuF5EiNw3LRbl+A3jEuQWzX8emsRWiXWSKouQJ8U4/P8sY08e7YwfVLwA2AQ9gBdZdITfl+sM7hztP6VUjzdkVqYNRFCU/iNfBbBSRvY0xcwCMMbNE5HBjTG8RCTsUuLYQSY+sS0tdo0VRlNpFvA7mL8B4EZmFFYPpCmyzj7m8YHzu0aCkCHbWTH/6vP1qpDWvXwfZ4VCIdpEpipInxCsV8xPWZMf3gRZYWmSDRKQ+1qTHWk29Os7++oi9asrtv3nFwZzc22GUtjoYRVHyhLglgI0xVcAr9l8g/3TFolwmwDlEXOcFaNu0HrSob62sA9BtMPw4MYXGKYqipBcXFzHJLKFqynZafVsGZlCarIgvu6n2bx/5Dxi10V1zFEVRMkjWOphk1ZRtbgBeToe9tnG+zS4tY1BXDnQw2jWmKEqekbUOhiTVlEXkaKwOqFWpNTOAjX6ZNO+8l4iOZkugaepgFEXJLxJbhjENGGOmikjHkGSfmjKAiHjVlOdRk/5AfSxHtF1E3jUmsMmQeiZdezhlDUO1QQP49ln/trZgFEXJM7LWwYTBSU35ALDUlIE7sdWUjTE32ennAWvCORcRuRi4GKB9ezeXtBH2bBHHImTqYBRFyTMy5mDSpKYcpKUW5ryxwFiA8vLyyEqVKUUdjKIo+UXGHEw+qikHE6evSm/vnaIoSsrJ5iC/Ez41ZRGpg6WmnB+TR6orM22BoiiKq2Stg8lFNeVg4uzyqtqVGjMURVEyRNYG+XNTTTkJqtXBKIqSX2RtC6bW0bRjpi1QFEVxFXUw2ULdGBckUxRFyRHUwSiKoigpQR2MoiiKkhLUwSiKoigpIWtHkcWLiOwO3AQ0NsYMEREPcAfQCJhhjHk2YgGKoiiKq2RtC8YFuf6TsGb678LSLEsvqi2mKEotJ2sdDEnK9QNdgS+NMdcCl6bQTmdMHFIx+5ybOjsURVEyRNY6GGPMVGBdSLJPrt8YUwF45fqdWAast7erwl1HRC62V72csXr16mTNToxBD2bmuoqiKCkkax1MGJzk+tuAJdcvIo9jy/UDE4BjReQRYGq4Ao0xY40x5caY8rKyshSaHgFPQWauqyiKkkLyXa4/dAllRVEUJU2oXH+q0CC/oii1nFzrIssduf54gvyKoih5SNY6mNyX61cURandZO1Ey1on168oipJnZG0LJufRGIyiKLUcdTBucvpzmbZAURQla1AH4yYtwokKKIqi1D7UwbiJ6ONUFEXxkjc1oojsLiLjRORVe7+9iLxhi2beGO18d4zIm8epKIqSNFlbI7qgptwLeNUYcwHQNz1Gx/E4d25JnR2KoihZQNY6GJJXU54GDBeRT4D3U2inn7pNY897d5vU2aEoipIFZK2DcUFN+XzgVmPMkcAJqbM0gJJGabmMoihKLpC1DiYM8agpvw9cZactCVdgVsj1K4qi5CH5rqY8JIbzxgJjAcrLy1VATFEUxSVUTVlRFEVJCbnWRZb9asp1m8WXv/1BqbFDURQlw2Stg6k1aso9Ts20BYqiKClB1ZTdJl6Ry56npcYORVGUDJO1LZjcJcTBfPkILJ+TGVMURVEySNa2YHIWbwvGu6Llhzdbn6M2ZsYeRVGUDKEtmEywMWDgm64boyhKnqIOJhNU7cy0BYqiKClHHYzreFskOmdTUZTaTd7EYETkZCzNsUbAOOAL4DGgAvjUGDM+TYZYn0YdjKIotZusbcEkINf/hjHmIiy5mKHAqVhy/RcBg9NoefoupSiKksVkrYMhcbn+m+08bfELY1al1FJHYmzB6CJliqLkKVlbu8Ur1y8W9wDvGWO+xVJabmufF/Y+XVdTjreLrG6T5K+pKIqSheRaDMZJrv8Ae/tKYADQWET2BJ4HHhWRE4C3whXovpqydpEpiqJAfsn1jwHGhCSfn4htrrB8Fqxb5N9//lQ4e0LGzFEURUk3KtfvNt4ushVzYUxff/ovH2fGHkVRlAyRtTGYMGS/XH9MaDeaoij5T9Y6mJyV698UoUFVnYHBbIqiKBkia4P8OSvXH4lta6FBC3SWv6IotYGsbcHkJTq7X1GUWoQ6mHRSXZlpCxRFUdKGOph08vFtmbZAURQlbWRtDCYv+fl9+OAm2K13pi1RlFrNrl27WLZsGTt27Mi0KTlDSUkJbdu2paioKOZz8sbBOKgp1wvcN8Z8mDnrbHZshK8ezbQVilLrWbZsGQ0bNqRjx46ILvoXFWMMa9euZdmyZXTq1Cnm87K2iyxZNWUHdWVFURQAduzYQfPmzdW5xIiI0Lx587hbfFnrYEheTTncfmop7Zq2SymKkjjqXOIjkeeVtQ4mWTVlB3Xl9NCwZdoupSiKks1krYMJg5Oacht726umPERELnHYd8R1uf7+I5MvQ1GUvEdEuO6663z7999/P6NGjUrZ9WbNmsW77/rnqE+cOJHRo0cDsHr1ag444AD69u3LZ599xiuvvEK3bt044ogjkrpmvqsph+47neeuXL8nb8ZNKIqSQoqLi5kwYQIjR46ktLQ05debNWsWM2bMYODAgQAMHjyYwYOtxX4//vhjevXqxZNPPgnAcccdxxNPPMEhhxyS1DVVTdltTHWmLVAUJQ5ue+sH5v2xydUyu7duxK0n9oiYp7CwkIsvvpgHH3yQO++8M+jYkiVLuOCCC1izZg1lZWU8/fTTtG/fnvPOO49GjRoxY8YMVqxYwb333suQIUNqlP3KK69w2223UVBQQOPGjZk0aRK33HIL27dv5/PPP2fkyJFs376dGTNmcOGFFzJixAjf/imnnMLnn3/O8OHDGTx4MPfdd1/CzyHXusiyX01ZHYyiKDFy+eWXM378eDZu3BiUfuWVV3LuuecyZ84chg0bxlVXXeU7tnz5cj7//HPefvttbrzxxtAiAbj99tv54IMPmD17NhMnTqROnTrcfvvtDB06lFmzZjF0qH9gbZ8+fYKO3XrrrZSXlzN+/PiknAtk8TwYW025P1AqIsuAW40x40TEq6ZcADyVdWrK8TiYbiemzg5FUWIiWksjlTRq1IhzzjmHMWPGULduXV/6V199xYQJ1gKFZ599NiNGjPAdO/nkk/F4PHTv3p2VK1c6lnvwwQdz3nnncfrpp3Pqqaem9iYikLUOJmfVlONxMMWNU2eHoig5wdVXX80+++zD+efHtgBvcXGxb9vYAro33XQT77zzDmDFWh5//HGmT5/OO++8w7777svMmTPdNzwGcq2LLPuJq4tM1ZUVpbbTrFkzTj/9dMaNG+dL69evH//73/8AGD9+PIceemjEMu68805mzZrFrFmzAPjll1844IADuP322ykrK2Pp0qU0bNiQzZs3p+w+nFAH4za6qJiiKHFy3XXXsWbNGt/+I488wtNPP83ee+/N888/z8MPPxxXeddffz29evWiZ8+e9OvXj969e3PEEUcwb948+vTpw0svveT2LTgiRtco8VFeXm5mzJiRXCELJsH402LL22cYnPxYctdTFCVufvzxR7p165ZpM3IOp+cmIjONMeVO+bUF4zatembaAkVRlKxAHYzbNHSaO6ooilL7yBsHIyIni8gTIvKSiBxjp9W3ZWAGZcSoPz0T+bh2TyqKksdkrYNJVq7fTr4BeDl9VofQ45SMXVpRFCXTZK2DIUm5fhE5GpgHrEq9qQmicuGKouQxWetgkpXrx1IBOBA4E7hIRBzv1XU1ZS9F9azPK2bA7mEUSbWLTFGUPCZrHUwYYpbrN8bcZIy5GngBeMIY5xmQxpixxphyY0x5WVmZO1ZeNx+unWdtl3aGYa+6U66iKHnDnXfeSY8ePdh7773p06cP06dP56GHHmLbtm2+PAMHDmTDhg0AjBkzhm7dujFs2DB27tzJgAED0jqnJRHyXa4fY8wz8VuXJKEjyQoK4ew34PmT026KoijZx1dffcXbb7/Nt99+S3FxMWvWrKGiooKhQ4dy1llnUa+e1QMSuH7LY489xqRJk2jbti3Tpk0D8M3cz1ZUrj9dtAgNFSmKkhW8dyOsmOtuma16wfGjwx5evnw5paWlPl2x0tJSxowZwx9//MERRxxBaWkpkydPpmPHjsyYMYObb76ZRYsWcfzxx3PWWWfxxBNPsHr1avr06cNrr73GHnvs4a79LpFrXWTZL9cfjgYtaqbteVT67VAUJeMcc8wxLF26lC5dunDZZZcxZcoUrrrqKlq3bs3kyZOZPHlyUP7HH3/cd+yGG27gySef5NBDD2XWrFlZ61wgi9WUc1auPxwicM0P8N8hsPpHK61H5mS0FUWxidDSSBUNGjRg5syZfPbZZ0yePJmhQ4f6li/OJ7LWweSsXH8kGreFflfAm5db+55ca0AqiuIWBQUF9O/fn/79+9OrVy+effbZTJvkOlrDpRuP7dN7nZ5ZOxRFyRjz589nwYIFvv1Zs2bRoUOHjEjqp5KsbcHkLUX2qnWegszaoShKxtiyZQtXXnklGzZsoLCwkD333JOxY8fy4osvctxxx/niLbmOyvUH4IpcfzSqKmHyP6HfVVCvWWqvpSiKIyrXnxjxyvVrCybdFBTCgFGZtkJRFCXl5I2DEZGTgROARsA4YBJwh70/wxiTfxE0RVGULCZrg/wuqCmfhDURcxeWpIyiKIoPDQ/ERyLPK2sdDEmqKQNdgS+NMdcCl6bcWkVRcoaSkhLWrl2rTiZGjDGsXbuWkpKSuM7L2i4yY8xUEekYkuxTUwYQEa+a8jwREWA0tpqy7Xgq7POq0mS2oig5QNu2bVm2bBmuKqjnOSUlJbRt2zauc7LWwYTBSU35AHvbq6bcWET2BJ4DHhGRQ4Gp4QoUkYuBiwHat2+fCpsVRckyioqK6NSpU6bNyHvyXU15eAznjQXGgjVMOd7rKoqiKM6omrKiKIqSErI5yO9E7qopK4qi1DKydiZ/oJoysBK/mvJA4CH8asp3unjN1cCvCZ5eCqxxy5YcQe+5dlDb7rm23S8kd88djDGOywFnrYPJNURkRji5hHxF77l2UNvuubbdL6TunnOti0xRFEXJEdTBKIqiKClBHYx7jM20ARlA77l2UNvuubbdL6TonjUGoyiKoqQEbcEoiqIoKUEdjKIoipIS1MEkSbjlA3IRpyUSRKSZiHwkIgvsz6Z2uojIGPu+54jIPgHnnGvnXyAi52biXmJFRNqJyGQRmSciP4jIX+30vL1vESkRka9FZLZ9z7fZ6Z1EZLp9by/Zk5kRkWJ7f6F9vGNAWSPt9PkicmyGbikmRKRARL4Tkbft/by+XwARWSIic0VklojMsNPS9902xuhfgn9Ykz1/AXYH6gCzge6ZtiuJ+zkM2Af4PiDtXuBGe/tG4B57eyDwHiDAgcB0O70ZsMj+bGpvN830vUW4592AfezthsDPWEtB5O1927Y3sLeLgOn2vbwMnGGnPw5cam9fBjxub58BvGRvd7e/88VAJ/u3UJDp+4tw39cCLwBv2/t5fb+2zUuA0pC0tH23tQWTHL7lA4wxFYB3+YCcxBgzFVgXknwS4F0N9Fng5ID054zFNKCJiOwGHAt8ZIxZZ4xZD3xEyLo+2YQxZrkx5lt7ezPwI5Zqd97et237Fnu3yP4zwJHAq3Z66D17n8WrwFH28hgnAf8zxuw0xiwGFmL9JrIOEWmLteLtk/a+kMf3G4W0fbfVwSSH0/IBbTJkS6poaYxZbm+vAFra2+HuPWefid0V0hfrjT6v79vuLpoFrMKqMH4BNhhjKu0sgfb77s0+vhFoTm7d80PACKDa3m9Oft+vFwN8KCIzxVqaBNL43c619WCUDGKMMSKSl+PaRaQB8BpwtTFmk/XCapGP922MqQL6iEgT4HVgr8xalDpEZBCwyhgzU0T6Z9icdHOIMeZ3EWkBfCQiPwUeTPV3W1swyVEblg9YaTeTsT9X2enh7j3nnomIFGE5l/HGmAl2ct7fN4AxZgMwGTgIq0vE+9IZaL/v3uzjjYG15M49HwwMFpElWN3YRwIPk7/368MY87v9uQrrRWJ/0vjdVgeTHLVh+YCJgHfUyLnAmwHp59gjTw4ENtrN7g+AY0SkqT065Rg7LSux+9bHAT8aYx4IOJS39y0iZXbLBRGpCxyNFXuaDAyxs4Xes/dZDAE+MVb0dyJwhj3qqhPQGfg6LTcRB8aYkcaYtsaYjli/0U+MMcPI0/v1IiL1RaShdxvrO/k96fxuZ3qUQ67/YY28+BmrD/umTNuT5L28CCwHdmH1sw7H6nv+GFgATAKa2XkF+Jd933OB8oByLsAKgC4Ezs/0fUW550Ow+qnnALPsv4H5fN/A3sB39j1/D9xip++OVWEuBF4Biu30Ent/oX1894CybrKfxXzg+EzfWwz33h//KLK8vl/7/mbbfz9466d0frdVKkZRFEVJCdpFpiiKoqQEdTCKoihKSlAHoyiKoqQEdTCKoihKSlAHoyiKoqQEdTCK4hIi8qX92VFEznS57L87XUtRshkdpqwoLmPLkfzNGDMojnMKjV8Xy+n4FmNMAxfMU5S0oS0YRXEJEfEqFI8GDrXX4LjGFpa8T0S+sdfZ+Iudv7+IfCYiE4F5dtobtjDhD15xQhEZDdS1yxsfeC171vV9IvK9WOt+DA0o+1MReVVEfhKR8bZqASIyWqz1b+aIyP3pfEZK7ULFLhXFfW4koAVjO4qNxpj9RKQY+EJEPrTz7gP0NJb8O8AFxph1toTLNyLymjHmRhG5whjTx+FapwJ9gN5AqX3OVPtYX6AH8AfwBXCwiPwInALsZYwxXskYRUkF2oJRlNRzDJbG0yyspQCaY+lYAXwd4FwArhKR2cA0LIHBzkTmEOBFY0yVMWYlMAXYL6DsZcaYaiwJnI5Y0vM7gHEiciqwLcl7U5SwqINRlNQjwJXGmD72XydjjLcFs9WXyYrdDAAOMsb0xtILK0niujsDtqsAb5xnf6yFtAYB7ydRvqJERB2MorjPZqzll718AFxqLwuAiHSx1W1DaQysN8ZsE5G9sJat9bLLe34InwFD7ThPGday12EVfu11bxobY94FrsHqWlOUlKAxGEVxnzlAld3V9QzW2iMdgW/tQPtq/MvUBvI+cIkdJ5mP1U3mZSwwR0S+NZbUvJfXsdZymY2lCj3CGLPCdlBONATeFJESrJbVtQndoaLEgA5TVhRFUVKCdpEpiqIoKUEdjKIoipIS1MEoiqIoKUEdjKIoipIS1MEoiqIoKUEdjKIoipIS1MEoiqIoKeH/AQWQCsSddyWhAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# s1 = np.loadtxt('values_non_stiff.txt', comments = \"#\", delimiter = \" \", unpack = False)\n",
    "# s2 = np.loadtxt('values_stiff.txt', comments = \"#\", delimiter = \" \", unpack = False)\n",
    "\n",
    "# #plot g_k_p_k\n",
    "# fig,ax = plt.subplots()\n",
    "# plt.semilogy(s1[:,0], label = 'Non-stiff')\n",
    "# plt.semilogy(s2[:,0], label = 'Stiff')\n",
    "# plt.yscale('symlog')\n",
    "# plt.xlabel('iterations')\n",
    "# plt.ylabel('$g_k^Tp_k$')\n",
    "# plt.legend()\n",
    "# plt.show()\n",
    "\n",
    "# # fig.savefig('g_k_p_k_compare.png', dpi = 500, bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save Weights\n",
    "[See Documentation](https://www.tensorflow.org/guide/intro_to_modules#saving_weights) or (see comments below)\n",
    "\n",
    "<!-- \n",
    "\n",
    "chkp_path = \"Non_Stiff_problem/my_checkpoint\"        # path to store file\n",
    "checkpoint = tf.train.Checkpoint(model = PINN)       # tf.Module can be saved as checkpoint\n",
    "checkpoint.write(chkp_path)                          # write to path \n",
    "\n",
    "tf.train.list_variables(chkp_path)                   # look inside checkpoint and ensure everything is saved\n",
    "\n",
    "PINN_2 = Sequentialmodel(layers)                     # instantiate new model \n",
    "new_checkpoint = tf.train.Checkpoint(model = PINN_2) # get checkpoint of new model\n",
    "chkp_path = \"Non_stiff/my_checkpoint\"                # define stored path\n",
    "new_checkpoint.restore(chkp_path)                    # overwrite variables  \n",
    "\n",
    "-->"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
